OnixS C++ CME MDP Conflated TCP Handler  1.2.1
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 
26 
27 
29 
30 // Market Data Serialization.
31 
32 /// Serializes into a string.
34 void
35 toStr(
36  std::string& str,
37  AggressorFlag::Enum value);
38 
39 
40 /// Serializes into a string.
41 inline
42 std::string
44  AggressorFlag::Enum value)
45 {
46  std::string str;
47 
48  toStr(str, value);
49 
50  return str;
51 }
52 
53 /// Serializes into a stream.
54 inline
55 std::ostream&
57  std::ostream& stream,
58  AggressorFlag::Enum value)
59 {
60  std::string str;
61 
62  toStr(str, value);
63 
64  return stream << str;
65 }
66 
67 /// Serializes the object into FIX presentation.
68 inline
69 void
71  std::string& str,
72  AggressorFlag::Enum value)
73 {
75  str,
76  static_cast<AggressorFlag::Base>(value));
77 }
78 
79 
80 /// Serializes into a string.
82 void
83 toStr(
84  std::string& str,
85  AggressorSide::Enum value);
86 
87 
88 /// Serializes into a string.
89 inline
90 std::string
92  AggressorSide::Enum value)
93 {
94  std::string str;
95 
96  toStr(str, value);
97 
98  return str;
99 }
100 
101 /// Serializes into a stream.
102 inline
103 std::ostream&
105  std::ostream& stream,
106  AggressorSide::Enum value)
107 {
108  std::string str;
109 
110  toStr(str, value);
111 
112  return stream << str;
113 }
114 
115 /// Serializes the object into FIX presentation.
116 inline
117 void
119  std::string& str,
120  AggressorSide::Enum value)
121 {
123  str,
124  static_cast<AggressorSide::Base>(value));
125 }
126 
127 
128 /// Serializes into a string.
130 void
131 toStr(
132  std::string& str,
133  MarketHrs::Enum value);
134 
135 
136 /// Serializes into a string.
137 inline std::string toStr(MarketHrs::Enum value)
138 {
139  std::string str;
140 
141  toStr(str, value);
142 
143  return str;
144 }
145 
146 /// Serializes into a stream.
147 inline
148 std::ostream&
150  std::ostream& stream,
151  MarketHrs::Enum value)
152 {
153  std::string str;
154 
155  toStr(str, value);
156 
157  return stream << str;
158 }
159 
160 /// Serializes the object into FIX presentation.
161 inline
162 void
164  std::string& str,
165  MarketHrs::Enum value)
166 {
168  str,
169  static_cast<MarketHrs::Base>(value));
170 }
171 
172 
173 /// Serializes into a string.
175 void
176 toStr(
177  std::string& str,
178  PreviousDayFlag::Enum value);
179 
180 
181 /// Serializes into a string.
182 inline
183 std::string
185  PreviousDayFlag::Enum value)
186 {
187  std::string str;
188 
189  toStr(str, value);
190 
191  return str;
192 }
193 
194 /// Serializes into a stream.
195 inline
196 std::ostream&
198  std::ostream& stream,
199  PreviousDayFlag::Enum value)
200 {
201  std::string str;
202 
203  toStr(str, value);
204 
205  return stream << str;
206 }
207 
208 /// Serializes the object into FIX presentation.
209 inline
210 void
212  std::string& str,
213  PreviousDayFlag::Enum value)
214 {
216  str,
217  static_cast<PreviousDayFlag::Base>(value));
218 }
219 
220 
221 /// Serializes into a string.
223 void
224 toStr(
225  std::string& str,
227 
228 
229 /// Serializes into a string.
230 inline
231 std::string
234 {
235  std::string str;
236 
237  toStr(str, value);
238 
239  return str;
240 }
241 
242 /// Serializes into a stream.
243 inline
244 std::ostream&
246  std::ostream& stream,
248 {
249  std::string str;
250 
251  toStr(str, value);
252 
253  return stream << str;
254 }
255 
256 /// Serializes the object into FIX presentation.
257 inline
258 void
260  std::string& str,
262 {
264  str,
265  static_cast<SpectrumSecurityTradingEvent::Base>(value));
266 }
267 
268 
269 /// Serializes into a string.
271 void
272 toStr(
273  std::string& str,
275 
276 
277 /// Serializes into a string.
278 inline
279 std::string
282 {
283  std::string str;
284 
285  toStr(str, value);
286 
287  return str;
288 }
289 
290 /// Serializes into a stream.
291 inline
292 std::ostream&
294  std::ostream& stream,
296 {
297  std::string str;
298 
299  toStr(str, value);
300 
301  return stream << str;
302 }
303 
304 /// Serializes the object into FIX presentation.
305 inline
306 void
308  std::string& str,
310 {
312  str,
313  static_cast<SpectrumEntryType::Base>(value));
314 }
315 
316 
317 /// Serializes into a string.
319 void
320 toStr(
321  std::string& str,
322  TickerEntryType::Enum value);
323 
324 
325 /// Serializes into a string.
326 inline
327 std::string
329  TickerEntryType::Enum value)
330 {
331  std::string str;
332 
333  toStr(str, value);
334 
335  return str;
336 }
337 
338 /// Serializes into a stream.
339 inline
340 std::ostream&
342  std::ostream& stream,
343  TickerEntryType::Enum value)
344 {
345  std::string str;
346 
347  toStr(str, value);
348 
349  return stream << str;
350 }
351 
352 /// Serializes the object into FIX presentation.
353 inline
354 void
356  std::string& str,
357  TickerEntryType::Enum value)
358 {
360  str,
361  static_cast<TickerEntryType::Base>(value));
362 }
363 
364 
365 /// Serializes into a string.
367 void
368 toStr(
369  std::string& str,
370  EventType::Enum value);
371 
372 
373 /// Serializes into a string.
374 inline std::string toStr(EventType::Enum value)
375 {
376  std::string str;
377 
378  Messaging::toStr(str, value);
379 
380  return str;
381 }
382 
383 /// Serializes into a stream.
384 inline
385 std::ostream&
387  std::ostream& stream,
388  EventType::Enum value)
389 {
390  std::string str;
391 
392  toStr(str, value);
393 
394  return stream << str;
395 }
396 
397 /// Serializes the object into FIX presentation.
398 inline
399 void
401  std::string& str,
402  EventType::Enum value)
403 {
405  str,
406  static_cast<EventType::Base>(value));
407 }
408 
409 
410 /// Serializes into a string.
412 void
413 toStr(
414  std::string& str,
415  HaltReason::Enum value);
416 
417 
418 /// Serializes into a string.
419 inline std::string toStr(HaltReason::Enum value)
420 {
421  std::string str;
422 
423  toStr(str, value);
424 
425  return str;
426 }
427 
428 /// Serializes into a stream.
429 inline
430 std::ostream&
432  std::ostream& stream,
433  HaltReason::Enum value)
434 {
435  std::string str;
436 
437  toStr(str, value);
438 
439  return stream << str;
440 }
441 
442 /// Serializes the object into FIX presentation.
443 inline
444 void
446  std::string& str,
447  HaltReason::Enum value)
448 {
450  str,
451  static_cast<HaltReason::Base>(value));
452 }
453 
454 
455 /// Serializes into a string.
457 void
458 toStr(
459  std::string& str,
460  LegSide::Enum value);
461 
462 
463 /// Serializes into a string.
464 inline std::string toStr(LegSide::Enum value)
465 {
466  std::string str;
467 
468  toStr(str, value);
469 
470  return str;
471 }
472 
473 /// Serializes into a stream.
474 inline
475 std::ostream&
477  std::ostream& stream,
478  LegSide::Enum value)
479 {
480  std::string str;
481 
482  toStr(str, value);
483 
484  return stream << str;
485 }
486 
487 /// Serializes the object into FIX presentation.
488 inline
489 void
491  std::string& str,
492  LegSide::Enum value)
493 {
495  str,
496  static_cast<LegSide::Base>(value));
497 }
498 
499 
500 /// Serializes into a string.
502 void
503 toStr(
504  std::string& str,
505  EntryType::Enum value);
506 
507 
508 /// Serializes into a string.
509 inline std::string toStr(EntryType::Enum value)
510 {
511  std::string str;
512 
513  toStr(str, value);
514 
515  return str;
516 }
517 
518 /// Serializes into a stream.
519 inline
520 std::ostream&
522  std::ostream& stream,
523  EntryType::Enum value)
524 {
525  std::string str;
526 
527  toStr(str, value);
528 
529  return stream << str;
530 }
531 
532 /// Serializes the object into FIX presentation.
533 inline
534 void
536  std::string& str,
537  EntryType::Enum value)
538 {
540  str,
541  static_cast<EntryType::Base>(value));
542 }
543 
544 
545 /// Serializes into a string.
547 void
548 toStr(
549  std::string& str,
550  EntryTypeBook::Enum value);
551 
552 
553 /// Serializes into a string.
554 inline
555 std::string
557  EntryTypeBook::Enum value)
558 {
559  std::string str;
560 
561  toStr(str, value);
562 
563  return str;
564 }
565 
566 /// Serializes into a stream.
567 inline
568 std::ostream&
570  std::ostream& stream,
571  EntryTypeBook::Enum value)
572 {
573  std::string str;
574 
575  toStr(str, value);
576 
577  return stream << str;
578 }
579 
580 /// Serializes the object into FIX presentation.
581 inline
582 void
584  std::string& str,
585  EntryTypeBook::Enum value)
586 {
588  str,
589  static_cast<EntryTypeBook::Base>(value));
590 }
591 
592 
593 /// Serializes into a string.
595 void
596 toStr(
597  std::string& str,
599 
600 
601 /// Serializes into a string.
602 inline
603 std::string
606 {
607  std::string str;
608 
609  toStr(str, value);
610 
611  return str;
612 }
613 
614 /// Serializes into a stream.
615 inline
616 std::ostream&
618  std::ostream& stream,
620 {
621  std::string str;
622 
623  toStr(str, value);
624 
625  return stream << str;
626 }
627 
628 /// Serializes the object into FIX presentation.
629 inline
630 void
632  std::string& str,
634 {
636  str,
637  static_cast<EntryTypeDailyStatistics::Base>(value));
638 }
639 
640 
641 /// Serializes into a string.
643 void
644 toStr(
645  std::string& str,
647 
648 
649 /// Serializes into a string.
650 inline
651 std::string
654 {
655  std::string str;
656 
657  toStr(str, value);
658 
659  return str;
660 }
661 
662 /// Serializes into a stream.
663 inline
664 std::ostream&
666  std::ostream& stream,
668 {
669  std::string str;
670 
671  toStr(str, value);
672 
673  return stream << str;
674 }
675 
676 /// Serializes the object into FIX presentation.
677 inline
678 void
680  std::string& str,
682 {
684  str,
685  static_cast<EntryTypeStatistics::Base>(value));
686 }
687 
688 
689 /// Serializes into a string.
691 void
692 toStr(
693  std::string& str,
694  UpdateAction::Enum value);
695 
696 
697 /// Serializes into a string.
698 inline std::string toStr(UpdateAction::Enum value)
699 {
700  std::string str;
701 
702  toStr(str, value);
703 
704  return str;
705 }
706 
707 /// Serializes into a stream.
708 inline
709 std::ostream&
711  std::ostream& stream,
712  UpdateAction::Enum value)
713 {
714  std::string str;
715 
716  toStr(str, value);
717 
718  return stream << str;
719 }
720 
721 /// Serializes the object into FIX presentation.
722 inline
723 void
725  std::string& str,
726  UpdateAction::Enum value)
727 {
729  str,
730  static_cast<UpdateAction::Base>(value));
731 }
732 
733 
734 /// Serializes into a string.
736 void
737 toStr(
738  std::string& str,
739  MoneyOrPar::Enum value);
740 
741 
742 /// Serializes into a string.
743 inline std::string toStr(MoneyOrPar::Enum value)
744 {
745  std::string str;
746 
747  toStr(str, value);
748 
749  return str;
750 }
751 
752 /// Serializes into a stream.
753 inline
754 std::ostream&
756  std::ostream& stream,
757  MoneyOrPar::Enum value)
758 {
759  std::string str;
760 
761  toStr(str, value);
762 
763  return stream << str;
764 }
765 
766 /// Serializes the object into FIX presentation.
767 inline
768 void
770  std::string& str,
771  MoneyOrPar::Enum value)
772 {
774  str,
775  static_cast<MoneyOrPar::Base>(value));
776 }
777 
778 
779 /// Serializes into a string.
781 void
782 toStr(
783  std::string& str,
785 
786 
787 /// Serializes into a string.
788 inline
789 std::string
792 {
793  std::string str;
794 
795  toStr(str, value);
796 
797  return str;
798 }
799 
800 /// Serializes into a stream.
801 inline
802 std::ostream&
804  std::ostream& stream,
806 {
807  std::string str;
808 
809  toStr(str, value);
810 
811  return stream << str;
812 }
813 
814 /// Serializes the object into FIX presentation.
815 inline
816 void
818  std::string& str,
820 {
822  str,
823  static_cast<OpenCloseSettlFlag::Base>(value));
824 }
825 
826 
827 /// Serializes into a string.
829 void
830 toStr(
831  std::string& str,
833 
834 
835 /// Serializes into a string.
836 inline
837 std::string
840 {
841  std::string str;
842 
843  toStr(str, value);
844 
845  return str;
846 }
847 
848 /// Serializes into a stream.
849 inline
850 std::ostream&
852  std::ostream& stream,
854 {
855  std::string str;
856 
857  toStr(str, value);
858 
859  return stream << str;
860 }
861 
862 /// Serializes the object into FIX presentation.
863 inline
864 void
866  std::string& str,
868 {
870  str,
871  static_cast<OrderUpdateAction::Base>(value));
872 }
873 
874 
875 /// Serializes into a string.
877 void
878 toStr(
879  std::string& str,
880  PriceSource::Enum value);
881 
882 
883 /// Serializes into a string.
884 inline std::string toStr(PriceSource::Enum value)
885 {
886  std::string str;
887 
888  toStr(str, value);
889 
890  return str;
891 }
892 
893 /// Serializes into a stream.
894 inline
895 std::ostream&
897  std::ostream& stream,
898  PriceSource::Enum value)
899 {
900  std::string str;
901 
902  toStr(str, value);
903 
904  return stream << str;
905 }
906 
907 /// Serializes the object into FIX presentation.
908 inline
909 void
911  std::string& str,
912  PriceSource::Enum value)
913 {
915  str,
916  static_cast<PriceSource::Base>(value));
917 }
918 
919 
920 /// Serializes into a string.
922 void
923 toStr(
924  std::string& str,
925  PutOrCall::Enum value);
926 
927 
928 /// Serializes into a string.
929 inline std::string toStr(PutOrCall::Enum value)
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,
943  PutOrCall::Enum value)
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,
957  PutOrCall::Enum value)
958 {
960  str,
961  static_cast<PutOrCall::Base>(value));
962 }
963 
964 
965 /// Serializes into a string.
967 void
968 toStr(
969  std::string& str,
970  RepoSubType::Enum value);
971 
972 
973 /// Serializes into a string.
974 inline std::string toStr(RepoSubType::Enum value)
975 {
976  std::string str;
977 
978  toStr(str, value);
979 
980  return str;
981 }
982 
983 /// Serializes into a stream.
984 inline
985 std::ostream&
987  std::ostream& stream,
988  RepoSubType::Enum value)
989 {
990  std::string str;
991 
992  toStr(str, value);
993 
994  return stream << str;
995 }
996 
997 /// Serializes the object into FIX presentation.
998 inline
999 void
1001  std::string& str,
1002  RepoSubType::Enum value)
1003 {
1005  str,
1006  static_cast<RepoSubType::Base>(value));
1007 }
1008 
1009 
1010 /// Serializes into a string.
1012 void
1013 toStr(
1014  std::string& str,
1016 
1017 
1018 /// Serializes into a string.
1019 inline
1020 std::string
1023 {
1024  std::string str;
1025 
1026  toStr(str, value);
1027 
1028  return str;
1029 }
1030 
1031 /// Serializes into a stream.
1032 inline
1033 std::ostream&
1035  std::ostream& stream,
1037 {
1038  std::string str;
1039 
1040  toStr(str, value);
1041 
1042  return stream << str;
1043 }
1044 
1045 /// Serializes the object into FIX presentation.
1046 inline
1047 void
1049  std::string& str,
1051 {
1053  str,
1054  static_cast<SecurityAltIDSource::Base>(value));
1055 }
1056 
1057 
1058 /// Serializes into a string.
1060 void
1061 toStr(
1062  std::string& str,
1064 
1065 
1066 /// Serializes into a string.
1067 inline
1068 std::string
1071 {
1072  std::string str;
1073 
1074  toStr(str, value);
1075 
1076  return str;
1077 }
1078 
1079 /// Serializes into a stream.
1080 inline
1081 std::ostream&
1083  std::ostream& stream,
1085 {
1086  std::string str;
1087 
1088  toStr(str, value);
1089 
1090  return stream << str;
1091 }
1092 
1093 /// Serializes the object into FIX presentation.
1094 inline
1095 void
1097  std::string& str,
1099 {
1101  str,
1102  static_cast<SecurityTradingEvent::Base>(value));
1103 }
1104 
1105 
1106 /// Serializes into a string.
1108 void
1109 toStr(
1110  std::string& str,
1112 
1113 
1114 /// Serializes into a string.
1115 inline
1116 std::string
1119 {
1120  std::string str;
1121 
1122  toStr(str, value);
1123 
1124  return str;
1125 }
1126 
1127 /// Serializes into a stream.
1128 inline
1129 std::ostream&
1131  std::ostream& stream,
1133 {
1134  std::string str;
1135 
1136  toStr(str, value);
1137 
1138  return stream << str;
1139 }
1140 
1141 /// Serializes the object into FIX presentation.
1142 inline
1143 void
1145  std::string& str,
1147 {
1149  str,
1150  static_cast<SecurityTradingStatus::Base>(value));
1151 }
1152 
1153 
1154 /// Serializes into a string.
1156 void
1157 toStr(
1158  std::string& str,
1160 
1161 
1162 /// Serializes into a string.
1163 inline
1164 std::string
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,
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,
1195 {
1197  str,
1198  static_cast<SecurityUpdateAction::Base>(value));
1199 }
1200 
1201 
1202 /// Serializes into a string.
1204 void
1205 toStr(
1206  std::string& str,
1207  Side::Enum value);
1208 
1209 
1210 /// Serializes into a string.
1211 inline std::string toStr(Side::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  Side::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  Side::Enum value)
1240 {
1242  str,
1243  static_cast<Side::Base>(value));
1244 }
1245 
1246 
1247 /// Serializes into a string.
1249 void
1250 toStr(
1251  std::string& str,
1253 
1254 
1255 /// Serializes into a string.
1256 inline
1257 std::string
1260 {
1261  std::string str;
1262 
1263  toStr(str, value);
1264 
1265  return str;
1266 }
1267 
1268 /// Serializes into a stream.
1269 inline
1270 std::ostream&
1272  std::ostream& stream,
1274 {
1275  std::string str;
1276 
1277  toStr(str, value);
1278 
1279  return stream << str;
1280 }
1281 
1282 /// Serializes the object into FIX presentation.
1283 inline
1284 void
1286  std::string& str,
1288 {
1290  str,
1291  static_cast<WorkupTradingStatus::Base>(value));
1292 }
1293 
1294 
1295 /// Serializes into a string.
1297 void
1298 toStr(
1299  std::string& str,
1300  InstAttribValue set);
1301 
1302 
1303 /// Serializes into a string.
1304 inline std::string toStr(InstAttribValue set)
1305 {
1306  std::string str;
1307 
1308  toStr(str, set);
1309 
1310  return str;
1311 }
1312 
1313 /// Serializes into a stream.
1314 inline
1315 std::ostream&
1317  std::ostream& stream,
1318  InstAttribValue set)
1319 {
1320  std::string str;
1321 
1322  toStr(str, set);
1323 
1324  return stream << str;
1325 }
1326 
1327 /// Serializes the object into FIX presentation.
1328 inline
1329 void
1331  std::string& str,
1332  InstAttribValue set)
1333 {
1334  Messaging::toStr(str, set.bits());
1335 }
1336 
1337 
1338 /// Serializes into a string.
1340 void
1341 toStr(
1342  std::string& str,
1343  MatchEventIndicator set);
1344 
1345 
1346 /// Serializes into a string.
1347 inline std::string toStr(MatchEventIndicator set)
1348 {
1349  std::string str;
1350 
1351  toStr(str, set);
1352 
1353  return str;
1354 }
1355 
1356 /// Serializes into a stream.
1357 inline
1358 std::ostream&
1360  std::ostream& stream,
1361  MatchEventIndicator set)
1362 {
1363  std::string str;
1364 
1365  toStr(str, set);
1366 
1367  return stream << str;
1368 }
1369 
1370 /// Serializes the object into FIX presentation.
1371 inline
1372 void
1374  std::string& str,
1375  MatchEventIndicator set)
1376 {
1377  Messaging::toStr(str, set.bits());
1378 }
1379 
1380 
1381 /// Serializes into a string.
1383 void
1384 toStr(
1385  std::string& str,
1386  SettlPriceType set);
1387 
1388 
1389 /// Serializes into a string.
1390 inline std::string toStr(SettlPriceType set)
1391 {
1392  std::string str;
1393 
1394  toStr(str, set);
1395 
1396  return str;
1397 }
1398 
1399 /// Serializes into a stream.
1400 inline
1401 std::ostream&
1403  std::ostream& stream,
1404  SettlPriceType set)
1405 {
1406  std::string str;
1407 
1408  toStr(str, set);
1409 
1410  return stream << str;
1411 }
1412 
1413 /// Serializes the object into FIX presentation.
1414 inline
1415 void
1417  std::string& str,
1418  SettlPriceType set)
1419 {
1420  Messaging::toStr(str, set.bits());
1421 }
1422 
1423 
1424 /// Serializes into a string.
1426 void
1427 toStr(
1428  std::string& str,
1429  EventIndicator set);
1430 
1431 
1432 /// Serializes into a string.
1433 inline std::string toStr(EventIndicator set)
1434 {
1435  std::string str;
1436 
1437  toStr(str, set);
1438 
1439  return str;
1440 }
1441 
1442 /// Serializes into a stream.
1443 inline
1444 std::ostream&
1446  std::ostream& stream,
1447  EventIndicator set)
1448 {
1449  std::string str;
1450 
1451  toStr(str, set);
1452 
1453  return stream << str;
1454 }
1455 
1456 /// Serializes the object into FIX presentation.
1457 inline
1458 void
1460  std::string& str,
1461  EventIndicator set)
1462 {
1463  Messaging::toStr(str, set.bits());
1464 }
1465 
1466 
1467 /// Serializes into a string.
1469 void
1470 toStr(
1471  std::string& str,
1472  const MaturityMonthYear& obj);
1473 
1474 
1475 /// Serializes into a string.
1476 inline
1477 std::string
1479  const MaturityMonthYear& obj)
1480 {
1481  std::string str;
1482 
1483  toStr(str, obj);
1484 
1485  return str;
1486 }
1487 
1488 /// Serializes into a stream.
1489 inline
1490 std::ostream&
1492  std::ostream& stream,
1493  const MaturityMonthYear& obj)
1494 {
1495  std::string str;
1496 
1497  toStr(str, obj);
1498 
1499  return stream << str;
1500 }
1501 
1502 inline std::string MaturityMonthYear::toString() const
1503 {
1504  return toStr(*this);
1505 }
1506 
1507 /// Serializes into a string.
1509 void
1510 toStr(
1511  std::string& str,
1512  const GroupSize& obj);
1513 
1514 
1515 /// Serializes into a string.
1516 inline std::string toStr(const GroupSize& obj)
1517 {
1518  std::string str;
1519 
1520  toStr(str, obj);
1521 
1522  return str;
1523 }
1524 
1525 /// Serializes into a stream.
1526 inline
1527 std::ostream&
1529  std::ostream& stream,
1530  const GroupSize& obj)
1531 {
1532  std::string str;
1533 
1534  toStr(str, obj);
1535 
1536  return stream << str;
1537 }
1538 
1539 
1540 /// Serializes into a string.
1542 void
1543 toStr(
1544  std::string& str,
1545  const GroupSize8Byte& obj);
1546 
1547 
1548 /// Serializes into a string.
1549 inline
1550 std::string
1552  const GroupSize8Byte& obj)
1553 {
1554  std::string str;
1555 
1556  toStr(str, obj);
1557 
1558  return str;
1559 }
1560 
1561 /// Serializes into a stream.
1562 inline
1563 std::ostream&
1565  std::ostream& stream,
1566  const GroupSize8Byte& obj)
1567 {
1568  std::string str;
1569 
1570  toStr(str, obj);
1571 
1572  return stream << str;
1573 }
1574 
1575 
1576 /// Serializes into a string.
1578 void
1579 toStr(
1580  std::string& str,
1581  const GroupSizeEncoding& obj);
1582 
1583 
1584 /// Serializes into a string.
1585 inline
1586 std::string
1588  const GroupSizeEncoding& obj)
1589 {
1590  std::string str;
1591 
1592  toStr(str, obj);
1593 
1594  return str;
1595 }
1596 
1597 /// Serializes into a stream.
1598 inline
1599 std::ostream&
1601  std::ostream& stream,
1602  const GroupSizeEncoding& obj)
1603 {
1604  std::string str;
1605 
1606  toStr(str, obj);
1607 
1608  return stream << str;
1609 }
1610 
1611 
1612 /// Serializes into a string.
1614 void
1615 toStr(
1616  std::string& str,
1617  const MessageHeader& obj);
1618 
1619 
1620 /// Serializes into a string.
1621 inline std::string toStr(const MessageHeader& obj)
1622 {
1623  std::string str;
1624 
1625  toStr(str, obj);
1626 
1627  return str;
1628 }
1629 
1630 /// Serializes into a stream.
1631 inline
1632 std::ostream&
1634  std::ostream& stream,
1635  const MessageHeader& obj)
1636 {
1637  std::string str;
1638 
1639  toStr(str, obj);
1640 
1641  return stream << str;
1642 }
1643 
1644 
1645 /// Serializes into a string.
1647 void
1648 toStr(
1649  std::string& str,
1651 
1652 
1653 /// Serializes into a string.
1654 inline
1655 std::string
1658 {
1659  std::string str;
1660 
1661  toStr(str, obj);
1662 
1663  return str;
1664 }
1665 
1666 /// Serializes into a stream.
1667 inline
1668 std::ostream&
1670  std::ostream& stream,
1672 {
1673  std::string str;
1674 
1675  toStr(str, obj);
1676 
1677  return stream << str;
1678 }
1679 
1680 /// Serializes the object into FIX presentation.
1682 void
1683 toFix(
1684  std::string& str,
1686 
1687 
1688 /// Serializes into a string.
1690 void
1691 toStr(
1692  std::string& str,
1694 
1695 /// Serializes into a string.
1696 inline
1697 std::string
1700 {
1701  std::string str;
1702 
1703  toStr(str, obj);
1704 
1705  return str;
1706 }
1707 
1708 /// Serializes into a stream.
1709 inline
1710 std::ostream&
1712  std::ostream& stream,
1714 {
1715  std::string str;
1716 
1717  toStr(str, obj);
1718 
1719  return stream << str;
1720 }
1721 
1722 /// Serializes into a string.
1724 void
1725 toStr(
1726  std::string& str,
1728 
1729 /// Serializes into a string.
1730 inline
1731 std::string
1734 {
1735  std::string str;
1736 
1737  toStr(str, obj);
1738 
1739  return str;
1740 }
1741 
1742 /// Serializes into a stream.
1743 inline
1744 std::ostream&
1746  std::ostream& stream,
1748 {
1749  std::string str;
1750 
1751  toStr(str, obj);
1752 
1753  return stream << str;
1754 }
1755 
1756 /// Serializes into a string.
1758 void
1759 toStr(
1760  std::string& str,
1762 
1763 /// Serializes into a string.
1764 inline
1765 std::string
1768 {
1769  std::string str;
1770 
1771  toStr(str, obj);
1772 
1773  return str;
1774 }
1775 
1776 /// Serializes into a stream.
1777 inline
1778 std::ostream&
1780  std::ostream& stream,
1782 {
1783  std::string str;
1784 
1785  toStr(str, obj);
1786 
1787  return stream << str;
1788 }
1789 
1790 /// Serializes into a string.
1792 void
1793 toStr(
1794  std::string& str,
1796 
1797 /// Serializes into a string.
1798 inline
1799 std::string
1802 {
1803  std::string str;
1804 
1805  toStr(str, obj);
1806 
1807  return str;
1808 }
1809 
1810 /// Serializes into a stream.
1811 inline
1812 std::ostream&
1814  std::ostream& stream,
1816 {
1817  std::string str;
1818 
1819  toStr(str, obj);
1820 
1821  return stream << str;
1822 }
1823 
1824 /// Serializes into a string.
1826 void
1827 toStr(
1828  std::string& str,
1829  const InstrumentDefinitionRepo58& obj);
1830 
1831 
1832 /// Serializes into a string.
1833 inline
1834 std::string
1836  const InstrumentDefinitionRepo58& obj)
1837 {
1838  std::string str;
1839 
1840  toStr(str, obj);
1841 
1842  return str;
1843 }
1844 
1845 /// Serializes into a stream.
1846 inline
1847 std::ostream&
1849  std::ostream& stream,
1850  const InstrumentDefinitionRepo58& obj)
1851 {
1852  std::string str;
1853 
1854  toStr(str, obj);
1855 
1856  return stream << str;
1857 }
1858 
1859 /// Serializes the object into FIX presentation.
1861 void
1862 toFix(
1863  std::string& str,
1864  const InstrumentDefinitionRepo58& obj);
1865 
1866 
1867 /// Serializes into a string.
1869 void
1870 toStr(
1871  std::string& str,
1873 
1874 /// Serializes into a string.
1875 inline
1876 std::string
1879 {
1880  std::string str;
1881 
1882  toStr(str, obj);
1883 
1884  return str;
1885 }
1886 
1887 /// Serializes into a stream.
1888 inline
1889 std::ostream&
1891  std::ostream& stream,
1893 {
1894  std::string str;
1895 
1896  toStr(str, obj);
1897 
1898  return stream << str;
1899 }
1900 
1901 /// Serializes into a string.
1903 void
1904 toStr(
1905  std::string& str,
1907 
1908 /// Serializes into a string.
1909 inline
1910 std::string
1913 {
1914  std::string str;
1915 
1916  toStr(str, obj);
1917 
1918  return str;
1919 }
1920 
1921 /// Serializes into a stream.
1922 inline
1923 std::ostream&
1925  std::ostream& stream,
1927 {
1928  std::string str;
1929 
1930  toStr(str, obj);
1931 
1932  return stream << str;
1933 }
1934 
1935 /// Serializes into a string.
1937 void
1938 toStr(
1939  std::string& str,
1941 
1942 /// Serializes into a string.
1943 inline
1944 std::string
1947 {
1948  std::string str;
1949 
1950  toStr(str, obj);
1951 
1952  return str;
1953 }
1954 
1955 /// Serializes into a stream.
1956 inline
1957 std::ostream&
1959  std::ostream& stream,
1961 {
1962  std::string str;
1963 
1964  toStr(str, obj);
1965 
1966  return stream << str;
1967 }
1968 
1969 /// Serializes into a string.
1971 void
1972 toStr(
1973  std::string& str,
1975 
1976 /// Serializes into a string.
1977 inline
1978 std::string
1981 {
1982  std::string str;
1983 
1984  toStr(str, obj);
1985 
1986  return str;
1987 }
1988 
1989 /// Serializes into a stream.
1990 inline
1991 std::ostream&
1993  std::ostream& stream,
1995 {
1996  std::string str;
1997 
1998  toStr(str, obj);
1999 
2000  return stream << str;
2001 }
2002 
2003 /// Serializes into a string.
2005 void
2006 toStr(
2007  std::string& str,
2009 
2010 /// Serializes into a string.
2011 inline
2012 std::string
2015 {
2016  std::string str;
2017 
2018  toStr(str, obj);
2019 
2020  return str;
2021 }
2022 
2023 /// Serializes into a stream.
2024 inline
2025 std::ostream&
2027  std::ostream& stream,
2029 {
2030  std::string str;
2031 
2032  toStr(str, obj);
2033 
2034  return stream << str;
2035 }
2036 
2037 /// Serializes into a string.
2039 void
2040 toStr(
2041  std::string& str,
2043 
2044 /// Serializes into a string.
2045 inline
2046 std::string
2049 {
2050  std::string str;
2051 
2052  toStr(str, obj);
2053 
2054  return str;
2055 }
2056 
2057 /// Serializes into a stream.
2058 inline
2059 std::ostream&
2061  std::ostream& stream,
2063 {
2064  std::string str;
2065 
2066  toStr(str, obj);
2067 
2068  return stream << str;
2069 }
2070 
2071 /// Serializes into a string.
2073 void
2074 toStr(
2075  std::string& str,
2076  const SnapshotRefreshTopOrders59& obj);
2077 
2078 
2079 /// Serializes into a string.
2080 inline
2081 std::string
2083  const SnapshotRefreshTopOrders59& obj)
2084 {
2085  std::string str;
2086 
2087  toStr(str, obj);
2088 
2089  return str;
2090 }
2091 
2092 /// Serializes into a stream.
2093 inline
2094 std::ostream&
2096  std::ostream& stream,
2097  const SnapshotRefreshTopOrders59& obj)
2098 {
2099  std::string str;
2100 
2101  toStr(str, obj);
2102 
2103  return stream << str;
2104 }
2105 
2106 /// Serializes the object into FIX presentation.
2108 void
2109 toFix(
2110  std::string& str,
2111  const SnapshotRefreshTopOrders59& obj);
2112 
2113 
2114 /// Serializes into a string.
2116 void
2117 toStr(
2118  std::string& str,
2120 
2121 /// Serializes into a string.
2122 inline
2123 std::string
2126 {
2127  std::string str;
2128 
2129  toStr(str, obj);
2130 
2131  return str;
2132 }
2133 
2134 /// Serializes into a stream.
2135 inline
2136 std::ostream&
2138  std::ostream& stream,
2140 {
2141  std::string str;
2142 
2143  toStr(str, obj);
2144 
2145  return stream << str;
2146 }
2147 
2148 /// Serializes into a string.
2150 void
2151 toStr(
2152  std::string& str,
2153  const SecurityStatusWorkup60& obj);
2154 
2155 
2156 /// Serializes into a string.
2157 inline
2158 std::string
2160  const SecurityStatusWorkup60& obj)
2161 {
2162  std::string str;
2163 
2164  toStr(str, obj);
2165 
2166  return str;
2167 }
2168 
2169 /// Serializes into a stream.
2170 inline
2171 std::ostream&
2173  std::ostream& stream,
2174  const SecurityStatusWorkup60& obj)
2175 {
2176  std::string str;
2177 
2178  toStr(str, obj);
2179 
2180  return stream << str;
2181 }
2182 
2183 /// Serializes the object into FIX presentation.
2185 void
2186 toFix(
2187  std::string& str,
2188  const SecurityStatusWorkup60& obj);
2189 
2190 
2191 /// Serializes into a string.
2193 void
2194 toStr(
2195  std::string& str,
2197 
2198 /// Serializes into a string.
2199 inline
2200 std::string
2203 {
2204  std::string str;
2205 
2206  toStr(str, obj);
2207 
2208  return str;
2209 }
2210 
2211 /// Serializes into a stream.
2212 inline
2213 std::ostream&
2215  std::ostream& stream,
2217 {
2218  std::string str;
2219 
2220  toStr(str, obj);
2221 
2222  return stream << str;
2223 }
2224 
2225 /// Serializes into a string.
2227 void
2228 toStr(
2229  std::string& str,
2230  const SnapshotFullRefreshTCP61& obj);
2231 
2232 
2233 /// Serializes into a string.
2234 inline
2235 std::string
2237  const SnapshotFullRefreshTCP61& obj)
2238 {
2239  std::string str;
2240 
2241  toStr(str, obj);
2242 
2243  return str;
2244 }
2245 
2246 /// Serializes into a stream.
2247 inline
2248 std::ostream&
2250  std::ostream& stream,
2251  const SnapshotFullRefreshTCP61& obj)
2252 {
2253  std::string str;
2254 
2255  toStr(str, obj);
2256 
2257  return stream << str;
2258 }
2259 
2260 /// Serializes the object into FIX presentation.
2262 void
2263 toFix(
2264  std::string& str,
2265  const SnapshotFullRefreshTCP61& obj);
2266 
2267 
2268 /// Serializes into a string.
2270 void
2271 toStr(
2272  std::string& str,
2273  const SnapshotFullRefreshTCP61::Entry& obj);
2274 
2275 /// Serializes into a string.
2276 inline
2277 std::string
2280 {
2281  std::string str;
2282 
2283  toStr(str, obj);
2284 
2285  return str;
2286 }
2287 
2288 /// Serializes into a stream.
2289 inline
2290 std::ostream&
2292  std::ostream& stream,
2294 {
2295  std::string str;
2296 
2297  toStr(str, obj);
2298 
2299  return stream << str;
2300 }
2301 
2302 /// Serializes into a string.
2304 void
2305 toStr(
2306  std::string& str,
2307  const CollateralMarketValue62& obj);
2308 
2309 
2310 /// Serializes into a string.
2311 inline
2312 std::string
2314  const CollateralMarketValue62& obj)
2315 {
2316  std::string str;
2317 
2318  toStr(str, obj);
2319 
2320  return str;
2321 }
2322 
2323 /// Serializes into a stream.
2324 inline
2325 std::ostream&
2327  std::ostream& stream,
2328  const CollateralMarketValue62& obj)
2329 {
2330  std::string str;
2331 
2332  toStr(str, obj);
2333 
2334  return stream << str;
2335 }
2336 
2337 /// Serializes the object into FIX presentation.
2339 void
2340 toFix(
2341  std::string& str,
2342  const CollateralMarketValue62& obj);
2343 
2344 
2345 /// Serializes into a string.
2347 void
2348 toStr(
2349  std::string& str,
2350  const CollateralMarketValue62::Entry& obj);
2351 
2352 /// Serializes into a string.
2353 inline
2354 std::string
2356  const CollateralMarketValue62::Entry& obj)
2357 {
2358  std::string str;
2359 
2360  toStr(str, obj);
2361 
2362  return str;
2363 }
2364 
2365 /// Serializes into a stream.
2366 inline
2367 std::ostream&
2369  std::ostream& stream,
2370  const CollateralMarketValue62::Entry& obj)
2371 {
2372  std::string str;
2373 
2374  toStr(str, obj);
2375 
2376  return stream << str;
2377 }
2378 
2379 /// Serializes into a string.
2381 void
2382 toStr(
2383  std::string& str,
2384  const InstrumentDefinitionFX63& obj);
2385 
2386 
2387 /// Serializes into a string.
2388 inline
2389 std::string
2391  const InstrumentDefinitionFX63& obj)
2392 {
2393  std::string str;
2394 
2395  toStr(str, obj);
2396 
2397  return str;
2398 }
2399 
2400 /// Serializes into a stream.
2401 inline
2402 std::ostream&
2404  std::ostream& stream,
2405  const InstrumentDefinitionFX63& obj)
2406 {
2407  std::string str;
2408 
2409  toStr(str, obj);
2410 
2411  return stream << str;
2412 }
2413 
2414 /// Serializes the object into FIX presentation.
2416 void
2417 toFix(
2418  std::string& str,
2419  const InstrumentDefinitionFX63& obj);
2420 
2421 
2422 /// Serializes into a string.
2424 void
2425 toStr(
2426  std::string& str,
2428 
2429 /// Serializes into a string.
2430 inline
2431 std::string
2434 {
2435  std::string str;
2436 
2437  toStr(str, obj);
2438 
2439  return str;
2440 }
2441 
2442 /// Serializes into a stream.
2443 inline
2444 std::ostream&
2446  std::ostream& stream,
2448 {
2449  std::string str;
2450 
2451  toStr(str, obj);
2452 
2453  return stream << str;
2454 }
2455 
2456 /// Serializes into a string.
2458 void
2459 toStr(
2460  std::string& str,
2462 
2463 /// Serializes into a string.
2464 inline
2465 std::string
2468 {
2469  std::string str;
2470 
2471  toStr(str, obj);
2472 
2473  return str;
2474 }
2475 
2476 /// Serializes into a stream.
2477 inline
2478 std::ostream&
2480  std::ostream& stream,
2482 {
2483  std::string str;
2484 
2485  toStr(str, obj);
2486 
2487  return stream << str;
2488 }
2489 
2490 /// Serializes into a string.
2492 void
2493 toStr(
2494  std::string& str,
2496 
2497 /// Serializes into a string.
2498 inline
2499 std::string
2502 {
2503  std::string str;
2504 
2505  toStr(str, obj);
2506 
2507  return str;
2508 }
2509 
2510 /// Serializes into a stream.
2511 inline
2512 std::ostream&
2514  std::ostream& stream,
2516 {
2517  std::string str;
2518 
2519  toStr(str, obj);
2520 
2521  return stream << str;
2522 }
2523 
2524 /// Serializes into a string.
2526 void
2527 toStr(
2528  std::string& str,
2530 
2531 /// Serializes into a string.
2532 inline
2533 std::string
2536 {
2537  std::string str;
2538 
2539  toStr(str, obj);
2540 
2541  return str;
2542 }
2543 
2544 /// Serializes into a stream.
2545 inline
2546 std::ostream&
2548  std::ostream& stream,
2550 {
2551  std::string str;
2552 
2553  toStr(str, obj);
2554 
2555  return stream << str;
2556 }
2557 
2558 /// Serializes into a string.
2560 void
2561 toStr(
2562  std::string& str,
2564 
2565 /// Serializes into a string.
2566 inline
2567 std::string
2570 {
2571  std::string str;
2572 
2573  toStr(str, obj);
2574 
2575  return str;
2576 }
2577 
2578 /// Serializes into a stream.
2579 inline
2580 std::ostream&
2582  std::ostream& stream,
2584 {
2585  std::string str;
2586 
2587  toStr(str, obj);
2588 
2589  return stream << str;
2590 }
2591 
2592 /// Serializes into a string.
2594 void
2595 toStr(
2596  std::string& str,
2597  const IncrementalRefreshBookLongQty64& obj);
2598 
2599 
2600 /// Serializes into a string.
2601 inline
2602 std::string
2605 {
2606  std::string str;
2607 
2608  toStr(str, obj);
2609 
2610  return str;
2611 }
2612 
2613 /// Serializes into a stream.
2614 inline
2615 std::ostream&
2617  std::ostream& stream,
2619 {
2620  std::string str;
2621 
2622  toStr(str, obj);
2623 
2624  return stream << str;
2625 }
2626 
2627 /// Serializes the object into FIX presentation.
2629 void
2630 toFix(
2631  std::string& str,
2632  const IncrementalRefreshBookLongQty64& obj);
2633 
2634 
2635 /// Serializes into a string.
2637 void
2638 toStr(
2639  std::string& str,
2641 
2642 /// Serializes into a string.
2643 inline
2644 std::string
2647 {
2648  std::string str;
2649 
2650  toStr(str, obj);
2651 
2652  return str;
2653 }
2654 
2655 /// Serializes into a stream.
2656 inline
2657 std::ostream&
2659  std::ostream& stream,
2661 {
2662  std::string str;
2663 
2664  toStr(str, obj);
2665 
2666  return stream << str;
2667 }
2668 
2669 /// Serializes into a string.
2671 void
2672 toStr(
2673  std::string& str,
2675 
2676 /// Serializes into a string.
2677 inline
2678 std::string
2681 {
2682  std::string str;
2683 
2684  toStr(str, obj);
2685 
2686  return str;
2687 }
2688 
2689 /// Serializes into a stream.
2690 inline
2691 std::ostream&
2693  std::ostream& stream,
2695 {
2696  std::string str;
2697 
2698  toStr(str, obj);
2699 
2700  return stream << str;
2701 }
2702 
2703 /// Serializes into a string.
2705 void
2706 toStr(
2707  std::string& str,
2709 
2710 
2711 /// Serializes into a string.
2712 inline
2713 std::string
2716 {
2717  std::string str;
2718 
2719  toStr(str, obj);
2720 
2721  return str;
2722 }
2723 
2724 /// Serializes into a stream.
2725 inline
2726 std::ostream&
2728  std::ostream& stream,
2730 {
2731  std::string str;
2732 
2733  toStr(str, obj);
2734 
2735  return stream << str;
2736 }
2737 
2738 /// Serializes the object into FIX presentation.
2740 void
2741 toFix(
2742  std::string& str,
2744 
2745 
2746 /// Serializes into a string.
2748 void
2749 toStr(
2750  std::string& str,
2752 
2753 /// Serializes into a string.
2754 inline
2755 std::string
2758 {
2759  std::string str;
2760 
2761  toStr(str, obj);
2762 
2763  return str;
2764 }
2765 
2766 /// Serializes into a stream.
2767 inline
2768 std::ostream&
2770  std::ostream& stream,
2772 {
2773  std::string str;
2774 
2775  toStr(str, obj);
2776 
2777  return stream << str;
2778 }
2779 
2780 /// Serializes into a string.
2782 void
2783 toStr(
2784  std::string& str,
2786 
2787 /// Serializes into a string.
2788 inline
2789 std::string
2792 {
2793  std::string str;
2794 
2795  toStr(str, obj);
2796 
2797  return str;
2798 }
2799 
2800 /// Serializes into a stream.
2801 inline
2802 std::ostream&
2804  std::ostream& stream,
2806 {
2807  std::string str;
2808 
2809  toStr(str, obj);
2810 
2811  return stream << str;
2812 }
2813 
2814 /// Serializes into a string.
2816 void
2817 toStr(
2818  std::string& str,
2820 
2821 
2822 /// Serializes into a string.
2823 inline
2824 std::string
2827 {
2828  std::string str;
2829 
2830  toStr(str, obj);
2831 
2832  return str;
2833 }
2834 
2835 /// Serializes into a stream.
2836 inline
2837 std::ostream&
2839  std::ostream& stream,
2841 {
2842  std::string str;
2843 
2844  toStr(str, obj);
2845 
2846  return stream << str;
2847 }
2848 
2849 /// Serializes the object into FIX presentation.
2851 void
2852 toFix(
2853  std::string& str,
2855 
2856 
2857 /// Serializes into a string.
2859 void
2860 toStr(
2861  std::string& str,
2863 
2864 /// Serializes into a string.
2865 inline
2866 std::string
2869 {
2870  std::string str;
2871 
2872  toStr(str, obj);
2873 
2874  return str;
2875 }
2876 
2877 /// Serializes into a stream.
2878 inline
2879 std::ostream&
2881  std::ostream& stream,
2883 {
2884  std::string str;
2885 
2886  toStr(str, obj);
2887 
2888  return stream << str;
2889 }
2890 
2891 /// Serializes into a string.
2893 void
2894 toStr(
2895  std::string& str,
2897 
2898 
2899 /// Serializes into a string.
2900 inline
2901 std::string
2904 {
2905  std::string str;
2906 
2907  toStr(str, obj);
2908 
2909  return str;
2910 }
2911 
2912 /// Serializes into a stream.
2913 inline
2914 std::ostream&
2916  std::ostream& stream,
2918 {
2919  std::string str;
2920 
2921  toStr(str, obj);
2922 
2923  return stream << str;
2924 }
2925 
2926 /// Serializes the object into FIX presentation.
2928 void
2929 toFix(
2930  std::string& str,
2932 
2933 
2934 /// Serializes into a string.
2936 void
2937 toStr(
2938  std::string& str,
2940 
2941 /// Serializes into a string.
2942 inline
2943 std::string
2946 {
2947  std::string str;
2948 
2949  toStr(str, obj);
2950 
2951  return str;
2952 }
2953 
2954 /// Serializes into a stream.
2955 inline
2956 std::ostream&
2958  std::ostream& stream,
2960 {
2961  std::string str;
2962 
2963  toStr(str, obj);
2964 
2965  return stream << str;
2966 }
2967 
2968 /// Serializes into a string.
2970 void
2971 toStr(
2972  std::string& str,
2973  const SnapshotFullRefreshTCPLongQty68& obj);
2974 
2975 
2976 /// Serializes into a string.
2977 inline
2978 std::string
2981 {
2982  std::string str;
2983 
2984  toStr(str, obj);
2985 
2986  return str;
2987 }
2988 
2989 /// Serializes into a stream.
2990 inline
2991 std::ostream&
2993  std::ostream& stream,
2995 {
2996  std::string str;
2997 
2998  toStr(str, obj);
2999 
3000  return stream << str;
3001 }
3002 
3003 /// Serializes the object into FIX presentation.
3005 void
3006 toFix(
3007  std::string& str,
3008  const SnapshotFullRefreshTCPLongQty68& obj);
3009 
3010 
3011 /// Serializes into a string.
3013 void
3014 toStr(
3015  std::string& str,
3017 
3018 /// Serializes into a string.
3019 inline
3020 std::string
3023 {
3024  std::string str;
3025 
3026  toStr(str, obj);
3027 
3028  return str;
3029 }
3030 
3031 /// Serializes into a stream.
3032 inline
3033 std::ostream&
3035  std::ostream& stream,
3037 {
3038  std::string str;
3039 
3040  toStr(str, obj);
3041 
3042  return stream << str;
3043 }
3044 
3045 /// Serializes into a string.
3047 void
3048 toStr(
3049  std::string& str,
3050  const SnapshotFullRefreshLongQty69& obj);
3051 
3052 
3053 /// Serializes into a string.
3054 inline
3055 std::string
3057  const SnapshotFullRefreshLongQty69& obj)
3058 {
3059  std::string str;
3060 
3061  toStr(str, obj);
3062 
3063  return str;
3064 }
3065 
3066 /// Serializes into a stream.
3067 inline
3068 std::ostream&
3070  std::ostream& stream,
3071  const SnapshotFullRefreshLongQty69& obj)
3072 {
3073  std::string str;
3074 
3075  toStr(str, obj);
3076 
3077  return stream << str;
3078 }
3079 
3080 /// Serializes the object into FIX presentation.
3082 void
3083 toFix(
3084  std::string& str,
3085  const SnapshotFullRefreshLongQty69& obj);
3086 
3087 
3088 /// Serializes into a string.
3090 void
3091 toStr(
3092  std::string& str,
3094 
3095 /// Serializes into a string.
3096 inline
3097 std::string
3100 {
3101  std::string str;
3102 
3103  toStr(str, obj);
3104 
3105  return str;
3106 }
3107 
3108 /// Serializes into a stream.
3109 inline
3110 std::ostream&
3112  std::ostream& stream,
3114 {
3115  std::string str;
3116 
3117  toStr(str, obj);
3118 
3119  return stream << str;
3120 }
3121 
3122 /// Serializes into a string.
3124 void
3125 toStr(
3126  std::string& str,
3127  const AdminHeartbeat302& obj);
3128 
3129 
3130 /// Serializes into a string.
3131 inline
3132 std::string
3134  const AdminHeartbeat302& obj)
3135 {
3136  std::string str;
3137 
3138  toStr(str, obj);
3139 
3140  return str;
3141 }
3142 
3143 /// Serializes into a stream.
3144 inline
3145 std::ostream&
3147  std::ostream& stream,
3148  const AdminHeartbeat302& obj)
3149 {
3150  std::string str;
3151 
3152  toStr(str, obj);
3153 
3154  return stream << str;
3155 }
3156 
3157 /// Serializes the object into FIX presentation.
3159 void
3160 toFix(
3161  std::string& str,
3162  const AdminHeartbeat302& obj);
3163 
3164 
3165 /// Serializes into a string.
3167 void
3168 toStr(
3169  std::string& str,
3170  const IncrementalRefreshSpectrum303& obj);
3171 
3172 
3173 /// Serializes into a string.
3174 inline
3175 std::string
3177  const IncrementalRefreshSpectrum303& obj)
3178 {
3179  std::string str;
3180 
3181  toStr(str, obj);
3182 
3183  return str;
3184 }
3185 
3186 /// Serializes into a stream.
3187 inline
3188 std::ostream&
3190  std::ostream& stream,
3191  const IncrementalRefreshSpectrum303& obj)
3192 {
3193  std::string str;
3194 
3195  toStr(str, obj);
3196 
3197  return stream << str;
3198 }
3199 
3200 /// Serializes the object into FIX presentation.
3202 void
3203 toFix(
3204  std::string& str,
3205  const IncrementalRefreshSpectrum303& obj);
3206 
3207 
3208 /// Serializes into a string.
3210 void
3211 toStr(
3212  std::string& str,
3214 
3215 /// Serializes into a string.
3216 inline
3217 std::string
3220 {
3221  std::string str;
3222 
3223  toStr(str, obj);
3224 
3225  return str;
3226 }
3227 
3228 /// Serializes into a stream.
3229 inline
3230 std::ostream&
3232  std::ostream& stream,
3234 {
3235  std::string str;
3236 
3237  toStr(str, obj);
3238 
3239  return stream << str;
3240 }
3241 
3242 /// Serializes into a string.
3244 void
3245 toStr(
3246  std::string& str,
3247  const IncrementalRefreshTicker304& obj);
3248 
3249 
3250 /// Serializes into a string.
3251 inline
3252 std::string
3254  const IncrementalRefreshTicker304& obj)
3255 {
3256  std::string str;
3257 
3258  toStr(str, obj);
3259 
3260  return str;
3261 }
3262 
3263 /// Serializes into a stream.
3264 inline
3265 std::ostream&
3267  std::ostream& stream,
3268  const IncrementalRefreshTicker304& obj)
3269 {
3270  std::string str;
3271 
3272  toStr(str, obj);
3273 
3274  return stream << str;
3275 }
3276 
3277 /// Serializes the object into FIX presentation.
3279 void
3280 toFix(
3281  std::string& str,
3282  const IncrementalRefreshTicker304& obj);
3283 
3284 
3285 /// Serializes into a string.
3287 void
3288 toStr(
3289  std::string& str,
3291 
3292 /// Serializes into a string.
3293 inline
3294 std::string
3297 {
3298  std::string str;
3299 
3300  toStr(str, obj);
3301 
3302  return str;
3303 }
3304 
3305 /// Serializes into a stream.
3306 inline
3307 std::ostream&
3309  std::ostream& stream,
3311 {
3312  std::string str;
3313 
3314  toStr(str, obj);
3315 
3316  return stream << str;
3317 }
3318 
3319 /// Serializes into a string.
3321 void
3322 toStr(
3323  std::string& str,
3324  const SnapshotRefreshSpectrum305& obj);
3325 
3326 
3327 /// Serializes into a string.
3328 inline
3329 std::string
3331  const SnapshotRefreshSpectrum305& obj)
3332 {
3333  std::string str;
3334 
3335  toStr(str, obj);
3336 
3337  return str;
3338 }
3339 
3340 /// Serializes into a stream.
3341 inline
3342 std::ostream&
3344  std::ostream& stream,
3345  const SnapshotRefreshSpectrum305& obj)
3346 {
3347  std::string str;
3348 
3349  toStr(str, obj);
3350 
3351  return stream << str;
3352 }
3353 
3354 /// Serializes the object into FIX presentation.
3356 void
3357 toFix(
3358  std::string& str,
3359  const SnapshotRefreshSpectrum305& obj);
3360 
3361 
3362 /// Serializes into a string.
3364 void
3365 toStr(
3366  std::string& str,
3368 
3369 /// Serializes into a string.
3370 inline
3371 std::string
3374 {
3375  std::string str;
3376 
3377  toStr(str, obj);
3378 
3379  return str;
3380 }
3381 
3382 /// Serializes into a stream.
3383 inline
3384 std::ostream&
3386  std::ostream& stream,
3388 {
3389  std::string str;
3390 
3391  toStr(str, obj);
3392 
3393  return stream << str;
3394 }
3395 
3396 /// Serializes into a string.
3398 void
3399 toStr(
3400  std::string& str,
3401  const SnapshotRefreshTicker306& obj);
3402 
3403 
3404 /// Serializes into a string.
3405 inline
3406 std::string
3408  const SnapshotRefreshTicker306& obj)
3409 {
3410  std::string str;
3411 
3412  toStr(str, obj);
3413 
3414  return str;
3415 }
3416 
3417 /// Serializes into a stream.
3418 inline
3419 std::ostream&
3421  std::ostream& stream,
3422  const SnapshotRefreshTicker306& obj)
3423 {
3424  std::string str;
3425 
3426  toStr(str, obj);
3427 
3428  return stream << str;
3429 }
3430 
3431 /// Serializes the object into FIX presentation.
3433 void
3434 toFix(
3435  std::string& str,
3436  const SnapshotRefreshTicker306& obj);
3437 
3438 
3439 /// Serializes into a string.
3441 void
3442 toStr(
3443  std::string& str,
3444  const SnapshotRefreshTicker306::Entry& obj);
3445 
3446 /// Serializes into a string.
3447 inline
3448 std::string
3451 {
3452  std::string str;
3453 
3454  toStr(str, obj);
3455 
3456  return str;
3457 }
3458 
3459 /// Serializes into a stream.
3460 inline
3461 std::ostream&
3463  std::ostream& stream,
3465 {
3466  std::string str;
3467 
3468  toStr(str, obj);
3469 
3470  return stream << str;
3471 }
3472 
3473 /// Serializes into a string.
3475 void
3476 toStr(
3477  std::string& str,
3478  const GlobalDayRoll307& obj);
3479 
3480 
3481 /// Serializes into a string.
3482 inline
3483 std::string
3485  const GlobalDayRoll307& obj)
3486 {
3487  std::string str;
3488 
3489  toStr(str, obj);
3490 
3491  return str;
3492 }
3493 
3494 /// Serializes into a stream.
3495 inline
3496 std::ostream&
3498  std::ostream& stream,
3499  const GlobalDayRoll307& obj)
3500 {
3501  std::string str;
3502 
3503  toStr(str, obj);
3504 
3505  return stream << str;
3506 }
3507 
3508 /// Serializes the object into FIX presentation.
3510 void
3511 toFix(
3512  std::string& str,
3513  const GlobalDayRoll307& obj);
3514 
3515 
3516 /// Serializes into a string.
3518 void
3519 toStr(
3520  std::string& str,
3521  const ChannelReset4& obj);
3522 
3523 
3524 /// Serializes into a string.
3525 inline std::string toStr(const ChannelReset4& obj)
3526 {
3527  std::string str;
3528 
3529  toStr(str, obj);
3530 
3531  return str;
3532 }
3533 
3534 /// Serializes into a stream.
3535 inline
3536 std::ostream&
3538  std::ostream& stream,
3539  const ChannelReset4& obj)
3540 {
3541  std::string str;
3542 
3543  toStr(str, obj);
3544 
3545  return stream << str;
3546 }
3547 
3548 /// Serializes the object into FIX presentation.
3550 void
3551 toFix(
3552  std::string& str,
3553  const ChannelReset4& obj);
3554 
3555 
3556 /// Serializes into a string.
3558 void
3559 toStr(
3560  std::string& str,
3561  const ChannelReset4::Entry& obj);
3562 
3563 /// Serializes into a string.
3564 inline
3565 std::string
3567  const ChannelReset4::Entry& obj)
3568 {
3569  std::string str;
3570 
3571  toStr(str, obj);
3572 
3573  return str;
3574 }
3575 
3576 /// Serializes into a stream.
3577 inline
3578 std::ostream&
3580  std::ostream& stream,
3581  const ChannelReset4::Entry& obj)
3582 {
3583  std::string str;
3584 
3585  toStr(str, obj);
3586 
3587  return stream << str;
3588 }
3589 
3590 /// Serializes into a string.
3592 void
3593 toStr(
3594  std::string& str,
3595  const AdminHeartbeat12& obj);
3596 
3597 
3598 /// Serializes into a string.
3599 inline
3600 std::string
3602  const AdminHeartbeat12& obj)
3603 {
3604  std::string str;
3605 
3606  toStr(str, obj);
3607 
3608  return str;
3609 }
3610 
3611 /// Serializes into a stream.
3612 inline
3613 std::ostream&
3615  std::ostream& stream,
3616  const AdminHeartbeat12& obj)
3617 {
3618  std::string str;
3619 
3620  toStr(str, obj);
3621 
3622  return stream << str;
3623 }
3624 
3625 /// Serializes the object into FIX presentation.
3627 void
3628 toFix(
3629  std::string& str,
3630  const AdminHeartbeat12& obj);
3631 
3632 
3633 /// Serializes into a string.
3635 void
3636 toStr(
3637  std::string& str,
3638  const AdminLogin15& obj);
3639 
3640 
3641 /// Serializes into a string.
3642 inline std::string toStr(const AdminLogin15& obj)
3643 {
3644  std::string str;
3645 
3646  toStr(str, obj);
3647 
3648  return str;
3649 }
3650 
3651 /// Serializes into a stream.
3652 inline
3653 std::ostream&
3655  std::ostream& stream,
3656  const AdminLogin15& obj)
3657 {
3658  std::string str;
3659 
3660  toStr(str, obj);
3661 
3662  return stream << str;
3663 }
3664 
3665 /// Serializes the object into FIX presentation.
3667 void
3668 toFix(
3669  std::string& str,
3670  const AdminLogin15& obj);
3671 
3672 
3673 /// Serializes into a string.
3675 void
3676 toStr(
3677  std::string& str,
3678  const AdminLogout16& obj);
3679 
3680 
3681 /// Serializes into a string.
3682 inline std::string toStr(const AdminLogout16& obj)
3683 {
3684  std::string str;
3685 
3686  toStr(str, obj);
3687 
3688  return str;
3689 }
3690 
3691 /// Serializes into a stream.
3692 inline
3693 std::ostream&
3695  std::ostream& stream,
3696  const AdminLogout16& obj)
3697 {
3698  std::string str;
3699 
3700  toStr(str, obj);
3701 
3702  return stream << str;
3703 }
3704 
3705 /// Serializes the object into FIX presentation.
3707 void
3708 toFix(
3709  std::string& str,
3710  const AdminLogout16& obj);
3711 
3712 
3713 /// Serializes into a string.
3715 void
3716 toStr(
3717  std::string& str,
3718  const InstrumentDefinitionFuture54& obj);
3719 
3720 
3721 /// Serializes into a string.
3722 inline
3723 std::string
3725  const InstrumentDefinitionFuture54& obj)
3726 {
3727  std::string str;
3728 
3729  toStr(str, obj);
3730 
3731  return str;
3732 }
3733 
3734 /// Serializes into a stream.
3735 inline
3736 std::ostream&
3738  std::ostream& stream,
3739  const InstrumentDefinitionFuture54& obj)
3740 {
3741  std::string str;
3742 
3743  toStr(str, obj);
3744 
3745  return stream << str;
3746 }
3747 
3748 /// Serializes the object into FIX presentation.
3750 void
3751 toFix(
3752  std::string& str,
3753  const InstrumentDefinitionFuture54& obj);
3754 
3755 
3756 /// Serializes into a string.
3758 void
3759 toStr(
3760  std::string& str,
3762 
3763 /// Serializes into a string.
3764 inline
3765 std::string
3768 {
3769  std::string str;
3770 
3771  toStr(str, obj);
3772 
3773  return str;
3774 }
3775 
3776 /// Serializes into a stream.
3777 inline
3778 std::ostream&
3780  std::ostream& stream,
3782 {
3783  std::string str;
3784 
3785  toStr(str, obj);
3786 
3787  return stream << str;
3788 }
3789 
3790 /// Serializes into a string.
3792 void
3793 toStr(
3794  std::string& str,
3796 
3797 /// Serializes into a string.
3798 inline
3799 std::string
3802 {
3803  std::string str;
3804 
3805  toStr(str, obj);
3806 
3807  return str;
3808 }
3809 
3810 /// Serializes into a stream.
3811 inline
3812 std::ostream&
3814  std::ostream& stream,
3816 {
3817  std::string str;
3818 
3819  toStr(str, obj);
3820 
3821  return stream << str;
3822 }
3823 
3824 /// Serializes into a string.
3826 void
3827 toStr(
3828  std::string& str,
3830 
3831 /// Serializes into a string.
3832 inline
3833 std::string
3836 {
3837  std::string str;
3838 
3839  toStr(str, obj);
3840 
3841  return str;
3842 }
3843 
3844 /// Serializes into a stream.
3845 inline
3846 std::ostream&
3848  std::ostream& stream,
3850 {
3851  std::string str;
3852 
3853  toStr(str, obj);
3854 
3855  return stream << str;
3856 }
3857 
3858 /// Serializes into a string.
3860 void
3861 toStr(
3862  std::string& str,
3864 
3865 /// Serializes into a string.
3866 inline
3867 std::string
3870 {
3871  std::string str;
3872 
3873  toStr(str, obj);
3874 
3875  return str;
3876 }
3877 
3878 /// Serializes into a stream.
3879 inline
3880 std::ostream&
3882  std::ostream& stream,
3884 {
3885  std::string str;
3886 
3887  toStr(str, obj);
3888 
3889  return stream << str;
3890 }
3891 
3892 /// Serializes into a string.
3894 void
3895 toStr(
3896  std::string& str,
3897  const InstrumentDefinitionSpread56& obj);
3898 
3899 
3900 /// Serializes into a string.
3901 inline
3902 std::string
3904  const InstrumentDefinitionSpread56& obj)
3905 {
3906  std::string str;
3907 
3908  toStr(str, obj);
3909 
3910  return str;
3911 }
3912 
3913 /// Serializes into a stream.
3914 inline
3915 std::ostream&
3917  std::ostream& stream,
3918  const InstrumentDefinitionSpread56& obj)
3919 {
3920  std::string str;
3921 
3922  toStr(str, obj);
3923 
3924  return stream << str;
3925 }
3926 
3927 /// Serializes the object into FIX presentation.
3929 void
3930 toFix(
3931  std::string& str,
3932  const InstrumentDefinitionSpread56& obj);
3933 
3934 
3935 /// Serializes into a string.
3937 void
3938 toStr(
3939  std::string& str,
3941 
3942 /// Serializes into a string.
3943 inline
3944 std::string
3947 {
3948  std::string str;
3949 
3950  toStr(str, obj);
3951 
3952  return str;
3953 }
3954 
3955 /// Serializes into a stream.
3956 inline
3957 std::ostream&
3959  std::ostream& stream,
3961 {
3962  std::string str;
3963 
3964  toStr(str, obj);
3965 
3966  return stream << str;
3967 }
3968 
3969 /// Serializes into a string.
3971 void
3972 toStr(
3973  std::string& str,
3975 
3976 /// Serializes into a string.
3977 inline
3978 std::string
3981 {
3982  std::string str;
3983 
3984  toStr(str, obj);
3985 
3986  return str;
3987 }
3988 
3989 /// Serializes into a stream.
3990 inline
3991 std::ostream&
3993  std::ostream& stream,
3995 {
3996  std::string str;
3997 
3998  toStr(str, obj);
3999 
4000  return stream << str;
4001 }
4002 
4003 /// Serializes into a string.
4005 void
4006 toStr(
4007  std::string& str,
4009 
4010 /// Serializes into a string.
4011 inline
4012 std::string
4015 {
4016  std::string str;
4017 
4018  toStr(str, obj);
4019 
4020  return str;
4021 }
4022 
4023 /// Serializes into a stream.
4024 inline
4025 std::ostream&
4027  std::ostream& stream,
4029 {
4030  std::string str;
4031 
4032  toStr(str, obj);
4033 
4034  return stream << str;
4035 }
4036 
4037 /// Serializes into a string.
4039 void
4040 toStr(
4041  std::string& str,
4043 
4044 /// Serializes into a string.
4045 inline
4046 std::string
4049 {
4050  std::string str;
4051 
4052  toStr(str, obj);
4053 
4054  return str;
4055 }
4056 
4057 /// Serializes into a stream.
4058 inline
4059 std::ostream&
4061  std::ostream& stream,
4063 {
4064  std::string str;
4065 
4066  toStr(str, obj);
4067 
4068  return stream << str;
4069 }
4070 
4071 /// Serializes into a string.
4073 void
4074 toStr(
4075  std::string& str,
4077 
4078 /// Serializes into a string.
4079 inline
4080 std::string
4083 {
4084  std::string str;
4085 
4086  toStr(str, obj);
4087 
4088  return str;
4089 }
4090 
4091 /// Serializes into a stream.
4092 inline
4093 std::ostream&
4095  std::ostream& stream,
4097 {
4098  std::string str;
4099 
4100  toStr(str, obj);
4101 
4102  return stream << str;
4103 }
4104 
4105 /// Serializes into a string.
4107 void
4108 toStr(
4109  std::string& str,
4110  const SecurityStatus30& obj);
4111 
4112 
4113 /// Serializes into a string.
4114 inline
4115 std::string
4117  const SecurityStatus30& obj)
4118 {
4119  std::string str;
4120 
4121  toStr(str, obj);
4122 
4123  return str;
4124 }
4125 
4126 /// Serializes into a stream.
4127 inline
4128 std::ostream&
4130  std::ostream& stream,
4131  const SecurityStatus30& obj)
4132 {
4133  std::string str;
4134 
4135  toStr(str, obj);
4136 
4137  return stream << str;
4138 }
4139 
4140 /// Serializes the object into FIX presentation.
4142 void
4143 toFix(
4144  std::string& str,
4145  const SecurityStatus30& obj);
4146 
4147 
4148 /// Serializes into a string.
4150 void
4151 toStr(
4152  std::string& str,
4153  const IncrementalRefreshBook46& obj);
4154 
4155 
4156 /// Serializes into a string.
4157 inline
4158 std::string
4160  const IncrementalRefreshBook46& obj)
4161 {
4162  std::string str;
4163 
4164  toStr(str, obj);
4165 
4166  return str;
4167 }
4168 
4169 /// Serializes into a stream.
4170 inline
4171 std::ostream&
4173  std::ostream& stream,
4174  const IncrementalRefreshBook46& obj)
4175 {
4176  std::string str;
4177 
4178  toStr(str, obj);
4179 
4180  return stream << str;
4181 }
4182 
4183 /// Serializes the object into FIX presentation.
4185 void
4186 toFix(
4187  std::string& str,
4188  const IncrementalRefreshBook46& obj);
4189 
4190 
4191 /// Serializes into a string.
4193 void
4194 toStr(
4195  std::string& str,
4196  const IncrementalRefreshBook46::Entry& obj);
4197 
4198 /// Serializes into a string.
4199 inline
4200 std::string
4203 {
4204  std::string str;
4205 
4206  toStr(str, obj);
4207 
4208  return str;
4209 }
4210 
4211 /// Serializes into a stream.
4212 inline
4213 std::ostream&
4215  std::ostream& stream,
4217 {
4218  std::string str;
4219 
4220  toStr(str, obj);
4221 
4222  return stream << str;
4223 }
4224 
4225 /// Serializes into a string.
4227 void
4228 toStr(
4229  std::string& str,
4231 
4232 /// Serializes into a string.
4233 inline
4234 std::string
4237 {
4238  std::string str;
4239 
4240  toStr(str, obj);
4241 
4242  return str;
4243 }
4244 
4245 /// Serializes into a stream.
4246 inline
4247 std::ostream&
4249  std::ostream& stream,
4251 {
4252  std::string str;
4253 
4254  toStr(str, obj);
4255 
4256  return stream << str;
4257 }
4258 
4259 /// Serializes into a string.
4261 void
4262 toStr(
4263  std::string& str,
4265 
4266 
4267 /// Serializes into a string.
4268 inline
4269 std::string
4272 {
4273  std::string str;
4274 
4275  toStr(str, obj);
4276 
4277  return str;
4278 }
4279 
4280 /// Serializes into a stream.
4281 inline
4282 std::ostream&
4284  std::ostream& stream,
4286 {
4287  std::string str;
4288 
4289  toStr(str, obj);
4290 
4291  return stream << str;
4292 }
4293 
4294 /// Serializes the object into FIX presentation.
4296 void
4297 toFix(
4298  std::string& str,
4300 
4301 
4302 /// Serializes into a string.
4304 void
4305 toStr(
4306  std::string& str,
4308 
4309 /// Serializes into a string.
4310 inline
4311 std::string
4314 {
4315  std::string str;
4316 
4317  toStr(str, obj);
4318 
4319  return str;
4320 }
4321 
4322 /// Serializes into a stream.
4323 inline
4324 std::ostream&
4326  std::ostream& stream,
4328 {
4329  std::string str;
4330 
4331  toStr(str, obj);
4332 
4333  return stream << str;
4334 }
4335 
4336 /// Serializes into a string.
4338 void
4339 toStr(
4340  std::string& str,
4342 
4343 
4344 /// Serializes into a string.
4345 inline
4346 std::string
4349 {
4350  std::string str;
4351 
4352  toStr(str, obj);
4353 
4354  return str;
4355 }
4356 
4357 /// Serializes into a stream.
4358 inline
4359 std::ostream&
4361  std::ostream& stream,
4363 {
4364  std::string str;
4365 
4366  toStr(str, obj);
4367 
4368  return stream << str;
4369 }
4370 
4371 /// Serializes the object into FIX presentation.
4373 void
4374 toFix(
4375  std::string& str,
4377 
4378 
4379 /// Serializes into a string.
4381 void
4382 toStr(
4383  std::string& str,
4385 
4386 /// Serializes into a string.
4387 inline
4388 std::string
4391 {
4392  std::string str;
4393 
4394  toStr(str, obj);
4395 
4396  return str;
4397 }
4398 
4399 /// Serializes into a stream.
4400 inline
4401 std::ostream&
4403  std::ostream& stream,
4405 {
4406  std::string str;
4407 
4408  toStr(str, obj);
4409 
4410  return stream << str;
4411 }
4412 
4413 /// Serializes into a string.
4415 void
4416 toStr(
4417  std::string& str,
4419 
4420 
4421 /// Serializes into a string.
4422 inline
4423 std::string
4426 {
4427  std::string str;
4428 
4429  toStr(str, obj);
4430 
4431  return str;
4432 }
4433 
4434 /// Serializes into a stream.
4435 inline
4436 std::ostream&
4438  std::ostream& stream,
4440 {
4441  std::string str;
4442 
4443  toStr(str, obj);
4444 
4445  return stream << str;
4446 }
4447 
4448 /// Serializes the object into FIX presentation.
4450 void
4451 toFix(
4452  std::string& str,
4454 
4455 
4456 /// Serializes into a string.
4458 void
4459 toStr(
4460  std::string& str,
4462 
4463 /// Serializes into a string.
4464 inline
4465 std::string
4468 {
4469  std::string str;
4470 
4471  toStr(str, obj);
4472 
4473  return str;
4474 }
4475 
4476 /// Serializes into a stream.
4477 inline
4478 std::ostream&
4480  std::ostream& stream,
4482 {
4483  std::string str;
4484 
4485  toStr(str, obj);
4486 
4487  return stream << str;
4488 }
4489 
4490 /// Serializes into a string.
4492 void
4493 toStr(
4494  std::string& str,
4495  const IncrementalRefreshVolume37& obj);
4496 
4497 
4498 /// Serializes into a string.
4499 inline
4500 std::string
4502  const IncrementalRefreshVolume37& obj)
4503 {
4504  std::string str;
4505 
4506  toStr(str, obj);
4507 
4508  return str;
4509 }
4510 
4511 /// Serializes into a stream.
4512 inline
4513 std::ostream&
4515  std::ostream& stream,
4516  const IncrementalRefreshVolume37& obj)
4517 {
4518  std::string str;
4519 
4520  toStr(str, obj);
4521 
4522  return stream << str;
4523 }
4524 
4525 /// Serializes the object into FIX presentation.
4527 void
4528 toFix(
4529  std::string& str,
4530  const IncrementalRefreshVolume37& obj);
4531 
4532 
4533 /// Serializes into a string.
4535 void
4536 toStr(
4537  std::string& str,
4539 
4540 /// Serializes into a string.
4541 inline
4542 std::string
4545 {
4546  std::string str;
4547 
4548  toStr(str, obj);
4549 
4550  return str;
4551 }
4552 
4553 /// Serializes into a stream.
4554 inline
4555 std::ostream&
4557  std::ostream& stream,
4559 {
4560  std::string str;
4561 
4562  toStr(str, obj);
4563 
4564  return stream << str;
4565 }
4566 
4567 /// Serializes into a string.
4569 void
4570 toStr(
4571  std::string& str,
4572  const SnapshotFullRefresh52& obj);
4573 
4574 
4575 /// Serializes into a string.
4576 inline
4577 std::string
4579  const SnapshotFullRefresh52& obj)
4580 {
4581  std::string str;
4582 
4583  toStr(str, obj);
4584 
4585  return str;
4586 }
4587 
4588 /// Serializes into a stream.
4589 inline
4590 std::ostream&
4592  std::ostream& stream,
4593  const SnapshotFullRefresh52& obj)
4594 {
4595  std::string str;
4596 
4597  toStr(str, obj);
4598 
4599  return stream << str;
4600 }
4601 
4602 /// Serializes the object into FIX presentation.
4604 void
4605 toFix(
4606  std::string& str,
4607  const SnapshotFullRefresh52& obj);
4608 
4609 
4610 /// Serializes into a string.
4612 void
4613 toStr(
4614  std::string& str,
4615  const SnapshotFullRefresh52::Entry& obj);
4616 
4617 /// Serializes into a string.
4618 inline
4619 std::string
4621  const SnapshotFullRefresh52::Entry& obj)
4622 {
4623  std::string str;
4624 
4625  toStr(str, obj);
4626 
4627  return str;
4628 }
4629 
4630 /// Serializes into a stream.
4631 inline
4632 std::ostream&
4634  std::ostream& stream,
4635  const SnapshotFullRefresh52::Entry& obj)
4636 {
4637  std::string str;
4638 
4639  toStr(str, obj);
4640 
4641  return stream << str;
4642 }
4643 
4644 /// Serializes into a string.
4646 void
4647 toStr(
4648  std::string& str,
4649  const QuoteRequest39& obj);
4650 
4651 
4652 /// Serializes into a string.
4653 inline
4654 std::string
4656  const QuoteRequest39& obj)
4657 {
4658  std::string str;
4659 
4660  toStr(str, obj);
4661 
4662  return str;
4663 }
4664 
4665 /// Serializes into a stream.
4666 inline
4667 std::ostream&
4669  std::ostream& stream,
4670  const QuoteRequest39& obj)
4671 {
4672  std::string str;
4673 
4674  toStr(str, obj);
4675 
4676  return stream << str;
4677 }
4678 
4679 /// Serializes the object into FIX presentation.
4681 void
4682 toFix(
4683  std::string& str,
4684  const QuoteRequest39& obj);
4685 
4686 
4687 /// Serializes into a string.
4689 void
4690 toStr(
4691  std::string& str,
4692  const QuoteRequest39::RelatedSymEntry& obj);
4693 
4694 /// Serializes into a string.
4695 inline
4696 std::string
4699 {
4700  std::string str;
4701 
4702  toStr(str, obj);
4703 
4704  return str;
4705 }
4706 
4707 /// Serializes into a stream.
4708 inline
4709 std::ostream&
4711  std::ostream& stream,
4713 {
4714  std::string str;
4715 
4716  toStr(str, obj);
4717 
4718  return stream << str;
4719 }
4720 
4721 /// Serializes into a string.
4723 void
4724 toStr(
4725  std::string& str,
4726  const InstrumentDefinitionOption55& obj);
4727 
4728 
4729 /// Serializes into a string.
4730 inline
4731 std::string
4733  const InstrumentDefinitionOption55& obj)
4734 {
4735  std::string str;
4736 
4737  toStr(str, obj);
4738 
4739  return str;
4740 }
4741 
4742 /// Serializes into a stream.
4743 inline
4744 std::ostream&
4746  std::ostream& stream,
4747  const InstrumentDefinitionOption55& obj)
4748 {
4749  std::string str;
4750 
4751  toStr(str, obj);
4752 
4753  return stream << str;
4754 }
4755 
4756 /// Serializes the object into FIX presentation.
4758 void
4759 toFix(
4760  std::string& str,
4761  const InstrumentDefinitionOption55& obj);
4762 
4763 
4764 /// Serializes into a string.
4766 void
4767 toStr(
4768  std::string& str,
4770 
4771 /// Serializes into a string.
4772 inline
4773 std::string
4776 {
4777  std::string str;
4778 
4779  toStr(str, obj);
4780 
4781  return str;
4782 }
4783 
4784 /// Serializes into a stream.
4785 inline
4786 std::ostream&
4788  std::ostream& stream,
4790 {
4791  std::string str;
4792 
4793  toStr(str, obj);
4794 
4795  return stream << str;
4796 }
4797 
4798 /// Serializes into a string.
4800 void
4801 toStr(
4802  std::string& str,
4804 
4805 /// Serializes into a string.
4806 inline
4807 std::string
4810 {
4811  std::string str;
4812 
4813  toStr(str, obj);
4814 
4815  return str;
4816 }
4817 
4818 /// Serializes into a stream.
4819 inline
4820 std::ostream&
4822  std::ostream& stream,
4824 {
4825  std::string str;
4826 
4827  toStr(str, obj);
4828 
4829  return stream << str;
4830 }
4831 
4832 /// Serializes into a string.
4834 void
4835 toStr(
4836  std::string& str,
4838 
4839 /// Serializes into a string.
4840 inline
4841 std::string
4844 {
4845  std::string str;
4846 
4847  toStr(str, obj);
4848 
4849  return str;
4850 }
4851 
4852 /// Serializes into a stream.
4853 inline
4854 std::ostream&
4856  std::ostream& stream,
4858 {
4859  std::string str;
4860 
4861  toStr(str, obj);
4862 
4863  return stream << str;
4864 }
4865 
4866 /// Serializes into a string.
4868 void
4869 toStr(
4870  std::string& str,
4872 
4873 /// Serializes into a string.
4874 inline
4875 std::string
4878 {
4879  std::string str;
4880 
4881  toStr(str, obj);
4882 
4883  return str;
4884 }
4885 
4886 /// Serializes into a stream.
4887 inline
4888 std::ostream&
4890  std::ostream& stream,
4892 {
4893  std::string str;
4894 
4895  toStr(str, obj);
4896 
4897  return stream << str;
4898 }
4899 
4900 /// Serializes into a string.
4902 void
4903 toStr(
4904  std::string& str,
4906 
4907 /// Serializes into a string.
4908 inline
4909 std::string
4912 {
4913  std::string str;
4914 
4915  toStr(str, obj);
4916 
4917  return str;
4918 }
4919 
4920 /// Serializes into a stream.
4921 inline
4922 std::ostream&
4924  std::ostream& stream,
4926 {
4927  std::string str;
4928 
4929  toStr(str, obj);
4930 
4931  return stream << str;
4932 }
4933 
4934 /// Serializes into a string.
4936 void
4937 toStr(
4938  std::string& str,
4940 
4941 /// Serializes into a string.
4942 inline
4943 std::string
4946 {
4947  std::string str;
4948 
4949  toStr(str, obj);
4950 
4951  return str;
4952 }
4953 
4954 /// Serializes into a stream.
4955 inline
4956 std::ostream&
4958  std::ostream& stream,
4960 {
4961  std::string str;
4962 
4963  toStr(str, obj);
4964 
4965  return stream << str;
4966 }
4967 
4968 /// Serializes into a string.
4970 void
4971 toStr(
4972  std::string& str,
4974 
4975 
4976 /// Serializes into a string.
4977 inline
4978 std::string
4981 {
4982  std::string str;
4983 
4984  toStr(str, obj);
4985 
4986  return str;
4987 }
4988 
4989 /// Serializes into a stream.
4990 inline
4991 std::ostream&
4993  std::ostream& stream,
4995 {
4996  std::string str;
4997 
4998  toStr(str, obj);
4999 
5000  return stream << str;
5001 }
5002 
5003 /// Serializes the object into FIX presentation.
5005 void
5006 toFix(
5007  std::string& str,
5009 
5010 
5011 /// Serializes into a string.
5013 void
5014 toStr(
5015  std::string& str,
5017 
5018 /// Serializes into a string.
5019 inline
5020 std::string
5023 {
5024  std::string str;
5025 
5026  toStr(str, obj);
5027 
5028  return str;
5029 }
5030 
5031 /// Serializes into a stream.
5032 inline
5033 std::ostream&
5035  std::ostream& stream,
5037 {
5038  std::string str;
5039 
5040  toStr(str, obj);
5041 
5042  return stream << str;
5043 }
5044 
5045 /// Serializes into a string.
5047 void
5048 toStr(
5049  std::string& str,
5051 
5052 /// Serializes into a string.
5053 inline
5054 std::string
5057 {
5058  std::string str;
5059 
5060  toStr(str, obj);
5061 
5062  return str;
5063 }
5064 
5065 /// Serializes into a stream.
5066 inline
5067 std::ostream&
5069  std::ostream& stream,
5071 {
5072  std::string str;
5073 
5074  toStr(str, obj);
5075 
5076  return stream << str;
5077 }
5078 
5079 /// Serializes into a string.
5081 void
5082 toStr(
5083  std::string& str,
5084  const IncrementalRefreshOrderBook47& obj);
5085 
5086 
5087 /// Serializes into a string.
5088 inline
5089 std::string
5091  const IncrementalRefreshOrderBook47& obj)
5092 {
5093  std::string str;
5094 
5095  toStr(str, obj);
5096 
5097  return str;
5098 }
5099 
5100 /// Serializes into a stream.
5101 inline
5102 std::ostream&
5104  std::ostream& stream,
5105  const IncrementalRefreshOrderBook47& obj)
5106 {
5107  std::string str;
5108 
5109  toStr(str, obj);
5110 
5111  return stream << str;
5112 }
5113 
5114 /// Serializes the object into FIX presentation.
5116 void
5117 toFix(
5118  std::string& str,
5119  const IncrementalRefreshOrderBook47& obj);
5120 
5121 
5122 /// Serializes into a string.
5124 void
5125 toStr(
5126  std::string& str,
5128 
5129 /// Serializes into a string.
5130 inline
5131 std::string
5134 {
5135  std::string str;
5136 
5137  toStr(str, obj);
5138 
5139  return str;
5140 }
5141 
5142 /// Serializes into a stream.
5143 inline
5144 std::ostream&
5146  std::ostream& stream,
5148 {
5149  std::string str;
5150 
5151  toStr(str, obj);
5152 
5153  return stream << str;
5154 }
5155 
5156 /// Serializes into a string.
5158 void
5159 toStr(
5160  std::string& str,
5161  const SnapshotFullRefreshOrderBook53& obj);
5162 
5163 
5164 /// Serializes into a string.
5165 inline
5166 std::string
5168  const SnapshotFullRefreshOrderBook53& obj)
5169 {
5170  std::string str;
5171 
5172  toStr(str, obj);
5173 
5174  return str;
5175 }
5176 
5177 /// Serializes into a stream.
5178 inline
5179 std::ostream&
5181  std::ostream& stream,
5182  const SnapshotFullRefreshOrderBook53& obj)
5183 {
5184  std::string str;
5185 
5186  toStr(str, obj);
5187 
5188  return stream << str;
5189 }
5190 
5191 /// Serializes the object into FIX presentation.
5193 void
5194 toFix(
5195  std::string& str,
5196  const SnapshotFullRefreshOrderBook53& obj);
5197 
5198 
5199 /// Serializes into a string.
5201 void
5202 toStr(
5203  std::string& str,
5205 
5206 /// Serializes into a string.
5207 inline
5208 std::string
5211 {
5212  std::string str;
5213 
5214  toStr(str, obj);
5215 
5216  return str;
5217 }
5218 
5219 /// Serializes into a stream.
5220 inline
5221 std::ostream&
5223  std::ostream& stream,
5225 {
5226  std::string str;
5227 
5228  toStr(str, obj);
5229 
5230  return stream << str;
5231 }
5232 
Number of repeating FeedType repeating group entries.
Definition: Messages.h:2499
std::string toStr(const SnapshotFullRefreshOrderBook53::Entry &obj)
Serializes into a string.
Number of data blocks listed in the Incremental message.
Definition: Messages.h:6292
Indicates the number of repeating symbols specified.
Definition: Messages.h:26380
void toFix(std::string &str, const SnapshotFullRefreshOrderBook53 &obj)
Serializes the object into FIX presentation.
#define ONIXS_CONFLATEDTCP_EXPORTED
Definition: Compiler.h:187
Template ID and length of message root.
Definition: Composites.h:330
#define ONIXS_CONFLATEDTCP_MESSAGING_MDP_NAMESPACE_BEGIN
Definition: ABI.h:148
#define ONIXS_CONFLATEDTCP_MESSAGING_MDP_NAMESPACE_END
Definition: ABI.h:152
Number of entries in Market Data message.
Definition: Messages.h:16702
8 Byte aligned repeating group dimensions.
Definition: Composites.h:219
Number of data blocks listed in the Incremental message.
Definition: Messages.h:7043
std::ostream & operator<<(std::ostream &stream, const SnapshotFullRefreshOrderBook53::Entry &obj)
Serializes into a stream.
Number of OrderID and LastQty entries in Trade Summary message.
Definition: Messages.h:10959