OnixS C++ CME iLink 3 Binary Order Entry Handler  1.9.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  AvgPxInd::Enum value);
38 
39 
40 /// Serializes into a string.
41 inline std::string toStr(AvgPxInd::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  AvgPxInd::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  AvgPxInd::Enum value)
70 {
71  toStr(
72  str,
73  static_cast<AvgPxInd::Base>(value));
74 }
75 
76 
77 /// Serializes into a string.
79 void
80 toStr(
81  std::string& str,
82  BooleanFlag::Enum value);
83 
84 
85 /// Serializes into a string.
86 inline std::string toStr(BooleanFlag::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  BooleanFlag::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  BooleanFlag::Enum value)
115 {
116  toStr(
117  str,
118  static_cast<BooleanFlag::Base>(value));
119 }
120 
121 
122 /// Serializes into a string.
124 void
125 toStr(
126  std::string& str,
127  BooleanNULL::Enum value);
128 
129 
130 /// Serializes into a string.
131 inline std::string toStr(BooleanNULL::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  BooleanNULL::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  BooleanNULL::Enum value)
160 {
161  toStr(
162  str,
163  static_cast<BooleanNULL::Base>(value));
164 }
165 
166 
167 /// Serializes into a string.
169 void
170 toStr(
171  std::string& str,
172  ClearingAcctType::Enum value);
173 
174 
175 /// Serializes into a string.
176 inline
177 std::string
180 {
181  std::string str;
182 
183  toStr(str, value);
184 
185  return str;
186 }
187 
188 /// Serializes into a stream.
189 inline
190 std::ostream&
192  std::ostream& stream,
194 {
195  std::string str;
196 
197  toStr(str, value);
198 
199  return stream << str;
200 }
201 
202 /// Serializes the object into FIX presentation.
203 inline
204 void
206  std::string& str,
208 {
209  toStr(
210  str,
211  static_cast<ClearingAcctType::Base>(value));
212 }
213 
214 
215 /// Serializes into a string.
217 void
218 toStr(
219  std::string& str,
220  CmtaGiveUpCD::Enum value);
221 
222 
223 /// Serializes into a string.
224 inline std::string toStr(CmtaGiveUpCD::Enum value)
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,
238  CmtaGiveUpCD::Enum value)
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,
252  CmtaGiveUpCD::Enum value)
253 {
254  toStr(
255  str,
256  static_cast<CmtaGiveUpCD::Base>(value));
257 }
258 
259 
260 /// Serializes into a string.
262 void
263 toStr(
264  std::string& str,
265  CustOrdHandlInst::Enum value);
266 
267 
268 /// Serializes into a string.
269 inline
270 std::string
273 {
274  std::string str;
275 
276  toStr(str, value);
277 
278  return str;
279 }
280 
281 /// Serializes into a stream.
282 inline
283 std::ostream&
285  std::ostream& stream,
287 {
288  std::string str;
289 
290  toStr(str, value);
291 
292  return stream << str;
293 }
294 
295 /// Serializes the object into FIX presentation.
296 inline
297 void
299  std::string& str,
301 {
302  toStr(
303  str,
304  static_cast<CustOrdHandlInst::Base>(value));
305 }
306 
307 
308 /// Serializes into a string.
310 void
311 toStr(
312  std::string& str,
314 
315 
316 /// Serializes into a string.
317 inline
318 std::string
321 {
322  std::string str;
323 
324  toStr(str, value);
325 
326  return str;
327 }
328 
329 /// Serializes into a stream.
330 inline
331 std::ostream&
333  std::ostream& stream,
335 {
336  std::string str;
337 
338  toStr(str, value);
339 
340  return stream << str;
341 }
342 
343 /// Serializes the object into FIX presentation.
344 inline
345 void
347  std::string& str,
349 {
350  toStr(
351  str,
352  static_cast<CustOrderCapacity::Base>(value));
353 }
354 
355 
356 /// Serializes into a string.
358 void
359 toStr(
360  std::string& str,
361  DKReason::Enum value);
362 
363 
364 /// Serializes into a string.
365 inline std::string toStr(DKReason::Enum value)
366 {
367  std::string str;
368 
369  toStr(str, value);
370 
371  return str;
372 }
373 
374 /// Serializes into a stream.
375 inline
376 std::ostream&
378  std::ostream& stream,
379  DKReason::Enum value)
380 {
381  std::string str;
382 
383  toStr(str, value);
384 
385  return stream << str;
386 }
387 
388 /// Serializes the object into FIX presentation.
389 inline
390 void
392  std::string& str,
393  DKReason::Enum value)
394 {
395  toStr(
396  str,
397  static_cast<DKReason::Base>(value));
398 }
399 
400 
401 /// Serializes into a string.
403 void
404 toStr(
405  std::string& str,
406  ExecAckStatus::Enum value);
407 
408 
409 /// Serializes into a string.
410 inline
411 std::string
413  ExecAckStatus::Enum value)
414 {
415  std::string str;
416 
417  toStr(str, value);
418 
419  return str;
420 }
421 
422 /// Serializes into a stream.
423 inline
424 std::ostream&
426  std::ostream& stream,
427  ExecAckStatus::Enum value)
428 {
429  std::string str;
430 
431  toStr(str, value);
432 
433  return stream << str;
434 }
435 
436 /// Serializes the object into FIX presentation.
437 inline
438 void
440  std::string& str,
441  ExecAckStatus::Enum value)
442 {
443  toStr(
444  str,
445  static_cast<ExecAckStatus::Base>(value));
446 }
447 
448 
449 /// Serializes into a string.
451 void
452 toStr(
453  std::string& str,
454  ExecMode::Enum value);
455 
456 
457 /// Serializes into a string.
458 inline std::string toStr(ExecMode::Enum value)
459 {
460  std::string str;
461 
462  toStr(str, value);
463 
464  return str;
465 }
466 
467 /// Serializes into a stream.
468 inline
469 std::ostream&
471  std::ostream& stream,
472  ExecMode::Enum value)
473 {
474  std::string str;
475 
476  toStr(str, value);
477 
478  return stream << str;
479 }
480 
481 /// Serializes the object into FIX presentation.
482 inline
483 void
485  std::string& str,
486  ExecMode::Enum value)
487 {
488  toStr(
489  str,
490  static_cast<ExecMode::Base>(value));
491 }
492 
493 
494 /// Serializes into a string.
496 void
497 toStr(
498  std::string& str,
499  ExecReason::Enum value);
500 
501 
502 /// Serializes into a string.
503 inline std::string toStr(ExecReason::Enum value)
504 {
505  std::string str;
506 
507  toStr(str, value);
508 
509  return str;
510 }
511 
512 /// Serializes into a stream.
513 inline
514 std::ostream&
516  std::ostream& stream,
517  ExecReason::Enum value)
518 {
519  std::string str;
520 
521  toStr(str, value);
522 
523  return stream << str;
524 }
525 
526 /// Serializes the object into FIX presentation.
527 inline
528 void
530  std::string& str,
531  ExecReason::Enum value)
532 {
533  toStr(
534  str,
535  static_cast<ExecReason::Base>(value));
536 }
537 
538 
539 /// Serializes into a string.
541 void
542 toStr(
543  std::string& str,
544  ExecTypTrdCxl::Enum value);
545 
546 
547 /// Serializes into a string.
548 inline
549 std::string
551  ExecTypTrdCxl::Enum value)
552 {
553  std::string str;
554 
555  toStr(str, value);
556 
557  return str;
558 }
559 
560 /// Serializes into a stream.
561 inline
562 std::ostream&
564  std::ostream& stream,
565  ExecTypTrdCxl::Enum value)
566 {
567  std::string str;
568 
569  toStr(str, value);
570 
571  return stream << str;
572 }
573 
574 /// Serializes the object into FIX presentation.
575 inline
576 void
578  std::string& str,
579  ExecTypTrdCxl::Enum value)
580 {
581  toStr(
582  str,
583  static_cast<ExecTypTrdCxl::Base>(value));
584 }
585 
586 
587 /// Serializes into a string.
589 void
590 toStr(
591  std::string& str,
592  ExpCycle::Enum value);
593 
594 
595 /// Serializes into a string.
596 inline std::string toStr(ExpCycle::Enum value)
597 {
598  std::string str;
599 
600  toStr(str, value);
601 
602  return str;
603 }
604 
605 /// Serializes into a stream.
606 inline
607 std::ostream&
609  std::ostream& stream,
610  ExpCycle::Enum value)
611 {
612  std::string str;
613 
614  toStr(str, value);
615 
616  return stream << str;
617 }
618 
619 /// Serializes the object into FIX presentation.
620 inline
621 void
623  std::string& str,
624  ExpCycle::Enum value)
625 {
626  toStr(
627  str,
628  static_cast<ExpCycle::Base>(value));
629 }
630 
631 
632 /// Serializes into a string.
634 void
635 toStr(
636  std::string& str,
637  FTI::Enum value);
638 
639 
640 /// Serializes into a string.
641 inline std::string toStr(FTI::Enum value)
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,
655  FTI::Enum value)
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,
669  FTI::Enum value)
670 {
671  toStr(
672  str,
673  static_cast<FTI::Base>(value));
674 }
675 
676 
677 /// Serializes into a string.
679 void
680 toStr(
681  std::string& str,
682  KeepAliveLapsed::Enum value);
683 
684 
685 /// Serializes into a string.
686 inline
687 std::string
689  KeepAliveLapsed::Enum value)
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,
703  KeepAliveLapsed::Enum value)
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,
717  KeepAliveLapsed::Enum value)
718 {
719  toStr(
720  str,
721  static_cast<KeepAliveLapsed::Base>(value));
722 }
723 
724 
725 /// Serializes into a string.
727 void
728 toStr(
729  std::string& str,
730  ListUpdAct::Enum value);
731 
732 
733 /// Serializes into a string.
734 inline std::string toStr(ListUpdAct::Enum value)
735 {
736  std::string str;
737 
738  toStr(str, value);
739 
740  return str;
741 }
742 
743 /// Serializes into a stream.
744 inline
745 std::ostream&
747  std::ostream& stream,
748  ListUpdAct::Enum value)
749 {
750  std::string str;
751 
752  toStr(str, value);
753 
754  return stream << str;
755 }
756 
757 /// Serializes the object into FIX presentation.
758 inline
759 void
761  std::string& str,
762  ListUpdAct::Enum value)
763 {
764  toStr(
765  str,
766  static_cast<ListUpdAct::Base>(value));
767 }
768 
769 
770 /// Serializes into a string.
772 void
773 toStr(
774  std::string& str,
775  ManualOrdInd::Enum value);
776 
777 
778 /// Serializes into a string.
779 inline std::string toStr(ManualOrdInd::Enum value)
780 {
781  std::string str;
782 
783  toStr(str, value);
784 
785  return str;
786 }
787 
788 /// Serializes into a stream.
789 inline
790 std::ostream&
792  std::ostream& stream,
793  ManualOrdInd::Enum value)
794 {
795  std::string str;
796 
797  toStr(str, value);
798 
799  return stream << str;
800 }
801 
802 /// Serializes the object into FIX presentation.
803 inline
804 void
806  std::string& str,
807  ManualOrdInd::Enum value)
808 {
809  toStr(
810  str,
811  static_cast<ManualOrdInd::Base>(value));
812 }
813 
814 
815 /// Serializes into a string.
817 void
818 toStr(
819  std::string& str,
820  ManualOrdIndReq::Enum value);
821 
822 
823 /// Serializes into a string.
824 inline
825 std::string
827  ManualOrdIndReq::Enum value)
828 {
829  std::string str;
830 
831  toStr(str, value);
832 
833  return str;
834 }
835 
836 /// Serializes into a stream.
837 inline
838 std::ostream&
840  std::ostream& stream,
841  ManualOrdIndReq::Enum value)
842 {
843  std::string str;
844 
845  toStr(str, value);
846 
847  return stream << str;
848 }
849 
850 /// Serializes the object into FIX presentation.
851 inline
852 void
854  std::string& str,
855  ManualOrdIndReq::Enum value)
856 {
857  toStr(
858  str,
859  static_cast<ManualOrdIndReq::Base>(value));
860 }
861 
862 
863 /// Serializes into a string.
865 void
866 toStr(
867  std::string& str,
868  MassActionOrdTyp::Enum value);
869 
870 
871 /// Serializes into a string.
872 inline
873 std::string
876 {
877  std::string str;
878 
879  toStr(str, value);
880 
881  return str;
882 }
883 
884 /// Serializes into a stream.
885 inline
886 std::ostream&
888  std::ostream& stream,
890 {
891  std::string str;
892 
893  toStr(str, value);
894 
895  return stream << str;
896 }
897 
898 /// Serializes the object into FIX presentation.
899 inline
900 void
902  std::string& str,
904 {
905  toStr(
906  str,
907  static_cast<MassActionOrdTyp::Base>(value));
908 }
909 
910 
911 /// Serializes into a string.
913 void
914 toStr(
915  std::string& str,
917 
918 
919 /// Serializes into a string.
920 inline
921 std::string
924 {
925  std::string str;
926 
927  toStr(str, value);
928 
929  return str;
930 }
931 
932 /// Serializes into a stream.
933 inline
934 std::ostream&
936  std::ostream& stream,
938 {
939  std::string str;
940 
941  toStr(str, value);
942 
943  return stream << str;
944 }
945 
946 /// Serializes the object into FIX presentation.
947 inline
948 void
950  std::string& str,
952 {
953  toStr(
954  str,
955  static_cast<MassActionResponse::Base>(value));
956 }
957 
958 
959 /// Serializes into a string.
961 void
962 toStr(
963  std::string& str,
964  MassActionScope::Enum value);
965 
966 
967 /// Serializes into a string.
968 inline
969 std::string
971  MassActionScope::Enum value)
972 {
973  std::string str;
974 
975  toStr(str, value);
976 
977  return str;
978 }
979 
980 /// Serializes into a stream.
981 inline
982 std::ostream&
984  std::ostream& stream,
985  MassActionScope::Enum value)
986 {
987  std::string str;
988 
989  toStr(str, value);
990 
991  return stream << str;
992 }
993 
994 /// Serializes the object into FIX presentation.
995 inline
996 void
998  std::string& str,
999  MassActionScope::Enum value)
1000 {
1001  toStr(
1002  str,
1003  static_cast<MassActionScope::Base>(value));
1004 }
1005 
1006 
1007 /// Serializes into a string.
1009 void
1010 toStr(
1011  std::string& str,
1012  MassCancelTIF::Enum value);
1013 
1014 
1015 /// Serializes into a string.
1016 inline
1017 std::string
1019  MassCancelTIF::Enum value)
1020 {
1021  std::string str;
1022 
1023  toStr(str, value);
1024 
1025  return str;
1026 }
1027 
1028 /// Serializes into a stream.
1029 inline
1030 std::ostream&
1032  std::ostream& stream,
1033  MassCancelTIF::Enum value)
1034 {
1035  std::string str;
1036 
1037  toStr(str, value);
1038 
1039  return stream << str;
1040 }
1041 
1042 /// Serializes the object into FIX presentation.
1043 inline
1044 void
1046  std::string& str,
1047  MassCancelTIF::Enum value)
1048 {
1049  toStr(
1050  str,
1051  static_cast<MassCancelTIF::Base>(value));
1052 }
1053 
1054 
1055 /// Serializes into a string.
1057 void
1058 toStr(
1059  std::string& str,
1060  MassCxlReqTyp::Enum value);
1061 
1062 
1063 /// Serializes into a string.
1064 inline
1065 std::string
1067  MassCxlReqTyp::Enum value)
1068 {
1069  std::string str;
1070 
1071  toStr(str, value);
1072 
1073  return str;
1074 }
1075 
1076 /// Serializes into a stream.
1077 inline
1078 std::ostream&
1080  std::ostream& stream,
1081  MassCxlReqTyp::Enum value)
1082 {
1083  std::string str;
1084 
1085  toStr(str, value);
1086 
1087  return stream << str;
1088 }
1089 
1090 /// Serializes the object into FIX presentation.
1091 inline
1092 void
1094  std::string& str,
1095  MassCxlReqTyp::Enum value)
1096 {
1097  toStr(
1098  str,
1099  static_cast<MassCxlReqTyp::Base>(value));
1100 }
1101 
1102 
1103 /// Serializes into a string.
1105 void
1106 toStr(
1107  std::string& str,
1108  MassStatusOrdTyp::Enum value);
1109 
1110 
1111 /// Serializes into a string.
1112 inline
1113 std::string
1115  MassStatusOrdTyp::Enum value)
1116 {
1117  std::string str;
1118 
1119  toStr(str, value);
1120 
1121  return str;
1122 }
1123 
1124 /// Serializes into a stream.
1125 inline
1126 std::ostream&
1128  std::ostream& stream,
1129  MassStatusOrdTyp::Enum value)
1130 {
1131  std::string str;
1132 
1133  toStr(str, value);
1134 
1135  return stream << str;
1136 }
1137 
1138 /// Serializes the object into FIX presentation.
1139 inline
1140 void
1142  std::string& str,
1143  MassStatusOrdTyp::Enum value)
1144 {
1145  toStr(
1146  str,
1147  static_cast<MassStatusOrdTyp::Base>(value));
1148 }
1149 
1150 
1151 /// Serializes into a string.
1153 void
1154 toStr(
1155  std::string& str,
1156  MassStatusReqTyp::Enum value);
1157 
1158 
1159 /// Serializes into a string.
1160 inline
1161 std::string
1163  MassStatusReqTyp::Enum value)
1164 {
1165  std::string str;
1166 
1167  toStr(str, value);
1168 
1169  return str;
1170 }
1171 
1172 /// Serializes into a stream.
1173 inline
1174 std::ostream&
1176  std::ostream& stream,
1177  MassStatusReqTyp::Enum value)
1178 {
1179  std::string str;
1180 
1181  toStr(str, value);
1182 
1183  return stream << str;
1184 }
1185 
1186 /// Serializes the object into FIX presentation.
1187 inline
1188 void
1190  std::string& str,
1191  MassStatusReqTyp::Enum value)
1192 {
1193  toStr(
1194  str,
1195  static_cast<MassStatusReqTyp::Base>(value));
1196 }
1197 
1198 
1199 /// Serializes into a string.
1201 void
1202 toStr(
1203  std::string& str,
1204  MassStatusTIF::Enum value);
1205 
1206 
1207 /// Serializes into a string.
1208 inline
1209 std::string
1211  MassStatusTIF::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  MassStatusTIF::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  MassStatusTIF::Enum value)
1240 {
1241  toStr(
1242  str,
1243  static_cast<MassStatusTIF::Base>(value));
1244 }
1245 
1246 
1247 /// Serializes into a string.
1249 void
1250 toStr(
1251  std::string& str,
1252  OFMOverrideReq::Enum value);
1253 
1254 
1255 /// Serializes into a string.
1256 inline
1257 std::string
1259  OFMOverrideReq::Enum value)
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,
1273  OFMOverrideReq::Enum value)
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,
1287  OFMOverrideReq::Enum value)
1288 {
1289  toStr(
1290  str,
1291  static_cast<OFMOverrideReq::Base>(value));
1292 }
1293 
1294 
1295 /// Serializes into a string.
1297 void
1298 toStr(
1299  std::string& str,
1300  OrdStatusTrd::Enum value);
1301 
1302 
1303 /// Serializes into a string.
1304 inline std::string toStr(OrdStatusTrd::Enum value)
1305 {
1306  std::string str;
1307 
1308  toStr(str, value);
1309 
1310  return str;
1311 }
1312 
1313 /// Serializes into a stream.
1314 inline
1315 std::ostream&
1317  std::ostream& stream,
1318  OrdStatusTrd::Enum value)
1319 {
1320  std::string str;
1321 
1322  toStr(str, value);
1323 
1324  return stream << str;
1325 }
1326 
1327 /// Serializes the object into FIX presentation.
1328 inline
1329 void
1331  std::string& str,
1332  OrdStatusTrd::Enum value)
1333 {
1334  toStr(
1335  str,
1336  static_cast<OrdStatusTrd::Base>(value));
1337 }
1338 
1339 
1340 /// Serializes into a string.
1342 void
1343 toStr(
1344  std::string& str,
1345  OrdStatusTrdCxl::Enum value);
1346 
1347 
1348 /// Serializes into a string.
1349 inline
1350 std::string
1352  OrdStatusTrdCxl::Enum value)
1353 {
1354  std::string str;
1355 
1356  toStr(str, value);
1357 
1358  return str;
1359 }
1360 
1361 /// Serializes into a stream.
1362 inline
1363 std::ostream&
1365  std::ostream& stream,
1366  OrdStatusTrdCxl::Enum value)
1367 {
1368  std::string str;
1369 
1370  toStr(str, value);
1371 
1372  return stream << str;
1373 }
1374 
1375 /// Serializes the object into FIX presentation.
1376 inline
1377 void
1379  std::string& str,
1380  OrdStatusTrdCxl::Enum value)
1381 {
1382  toStr(
1383  str,
1384  static_cast<OrdStatusTrdCxl::Base>(value));
1385 }
1386 
1387 
1388 /// Serializes into a string.
1390 void
1391 toStr(
1392  std::string& str,
1393  OrderEventType::Enum value);
1394 
1395 
1396 /// Serializes into a string.
1397 inline
1398 std::string
1400  OrderEventType::Enum value)
1401 {
1402  std::string str;
1403 
1404  toStr(str, value);
1405 
1406  return str;
1407 }
1408 
1409 /// Serializes into a stream.
1410 inline
1411 std::ostream&
1413  std::ostream& stream,
1414  OrderEventType::Enum value)
1415 {
1416  std::string str;
1417 
1418  toStr(str, value);
1419 
1420  return stream << str;
1421 }
1422 
1423 /// Serializes the object into FIX presentation.
1424 inline
1425 void
1427  std::string& str,
1428  OrderEventType::Enum value)
1429 {
1430  toStr(
1431  str,
1432  static_cast<OrderEventType::Base>(value));
1433 }
1434 
1435 
1436 /// Serializes into a string.
1438 void
1439 toStr(
1440  std::string& str,
1441  OrderStatus::Enum value);
1442 
1443 
1444 /// Serializes into a string.
1445 inline std::string toStr(OrderStatus::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  OrderStatus::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  OrderStatus::Enum value)
1474 {
1475  toStr(
1476  str,
1477  static_cast<OrderStatus::Base>(value));
1478 }
1479 
1480 
1481 /// Serializes into a string.
1483 void
1484 toStr(
1485  std::string& str,
1486  OrderType::Enum value);
1487 
1488 
1489 /// Serializes into a string.
1490 inline std::string toStr(OrderType::Enum value)
1491 {
1492  std::string str;
1493 
1494  toStr(str, value);
1495 
1496  return str;
1497 }
1498 
1499 /// Serializes into a stream.
1500 inline
1501 std::ostream&
1503  std::ostream& stream,
1504  OrderType::Enum value)
1505 {
1506  std::string str;
1507 
1508  toStr(str, value);
1509 
1510  return stream << str;
1511 }
1512 
1513 /// Serializes the object into FIX presentation.
1514 inline
1515 void
1517  std::string& str,
1518  OrderType::Enum value)
1519 {
1520  toStr(
1521  str,
1522  static_cast<OrderType::Base>(value));
1523 }
1524 
1525 
1526 /// Serializes into a string.
1528 void
1529 toStr(
1530  std::string& str,
1531  OrderTypeReq::Enum value);
1532 
1533 
1534 /// Serializes into a string.
1535 inline std::string toStr(OrderTypeReq::Enum value)
1536 {
1537  std::string str;
1538 
1539  toStr(str, value);
1540 
1541  return str;
1542 }
1543 
1544 /// Serializes into a stream.
1545 inline
1546 std::ostream&
1548  std::ostream& stream,
1549  OrderTypeReq::Enum value)
1550 {
1551  std::string str;
1552 
1553  toStr(str, value);
1554 
1555  return stream << str;
1556 }
1557 
1558 /// Serializes the object into FIX presentation.
1559 inline
1560 void
1562  std::string& str,
1563  OrderTypeReq::Enum value)
1564 {
1565  toStr(
1566  str,
1567  static_cast<OrderTypeReq::Base>(value));
1568 }
1569 
1570 
1571 /// Serializes into a string.
1573 void
1574 toStr(
1575  std::string& str,
1576  PartyDetailRole::Enum value);
1577 
1578 
1579 /// Serializes into a string.
1580 inline
1581 std::string
1583  PartyDetailRole::Enum value)
1584 {
1585  std::string str;
1586 
1587  toStr(str, value);
1588 
1589  return str;
1590 }
1591 
1592 /// Serializes into a stream.
1593 inline
1594 std::ostream&
1596  std::ostream& stream,
1597  PartyDetailRole::Enum value)
1598 {
1599  std::string str;
1600 
1601  toStr(str, value);
1602 
1603  return stream << str;
1604 }
1605 
1606 /// Serializes the object into FIX presentation.
1607 inline
1608 void
1610  std::string& str,
1611  PartyDetailRole::Enum value)
1612 {
1613  toStr(
1614  str,
1615  static_cast<PartyDetailRole::Base>(value));
1616 }
1617 
1618 
1619 /// Serializes into a string.
1621 void
1622 toStr(
1623  std::string& str,
1624  QuoteAckStatus::Enum value);
1625 
1626 
1627 /// Serializes into a string.
1628 inline
1629 std::string
1631  QuoteAckStatus::Enum value)
1632 {
1633  std::string str;
1634 
1635  toStr(str, value);
1636 
1637  return str;
1638 }
1639 
1640 /// Serializes into a stream.
1641 inline
1642 std::ostream&
1644  std::ostream& stream,
1645  QuoteAckStatus::Enum value)
1646 {
1647  std::string str;
1648 
1649  toStr(str, value);
1650 
1651  return stream << str;
1652 }
1653 
1654 /// Serializes the object into FIX presentation.
1655 inline
1656 void
1658  std::string& str,
1659  QuoteAckStatus::Enum value)
1660 {
1661  toStr(
1662  str,
1663  static_cast<QuoteAckStatus::Base>(value));
1664 }
1665 
1666 
1667 /// Serializes into a string.
1669 void
1670 toStr(
1671  std::string& str,
1672  QuoteCxlStatus::Enum value);
1673 
1674 
1675 /// Serializes into a string.
1676 inline
1677 std::string
1679  QuoteCxlStatus::Enum value)
1680 {
1681  std::string str;
1682 
1683  toStr(str, value);
1684 
1685  return str;
1686 }
1687 
1688 /// Serializes into a stream.
1689 inline
1690 std::ostream&
1692  std::ostream& stream,
1693  QuoteCxlStatus::Enum value)
1694 {
1695  std::string str;
1696 
1697  toStr(str, value);
1698 
1699  return stream << str;
1700 }
1701 
1702 /// Serializes the object into FIX presentation.
1703 inline
1704 void
1706  std::string& str,
1707  QuoteCxlStatus::Enum value)
1708 {
1709  toStr(
1710  str,
1711  static_cast<QuoteCxlStatus::Base>(value));
1712 }
1713 
1714 
1715 /// Serializes into a string.
1717 void
1718 toStr(
1719  std::string& str,
1720  QuoteCxlTyp::Enum value);
1721 
1722 
1723 /// Serializes into a string.
1724 inline std::string toStr(QuoteCxlTyp::Enum value)
1725 {
1726  std::string str;
1727 
1728  toStr(str, value);
1729 
1730  return str;
1731 }
1732 
1733 /// Serializes into a stream.
1734 inline
1735 std::ostream&
1737  std::ostream& stream,
1738  QuoteCxlTyp::Enum value)
1739 {
1740  std::string str;
1741 
1742  toStr(str, value);
1743 
1744  return stream << str;
1745 }
1746 
1747 /// Serializes the object into FIX presentation.
1748 inline
1749 void
1751  std::string& str,
1752  QuoteCxlTyp::Enum value)
1753 {
1754  toStr(
1755  str,
1756  static_cast<QuoteCxlTyp::Base>(value));
1757 }
1758 
1759 
1760 /// Serializes into a string.
1762 void
1763 toStr(
1764  std::string& str,
1765  QuoteTyp::Enum value);
1766 
1767 
1768 /// Serializes into a string.
1769 inline std::string toStr(QuoteTyp::Enum value)
1770 {
1771  std::string str;
1772 
1773  toStr(str, value);
1774 
1775  return str;
1776 }
1777 
1778 /// Serializes into a stream.
1779 inline
1780 std::ostream&
1782  std::ostream& stream,
1783  QuoteTyp::Enum value)
1784 {
1785  std::string str;
1786 
1787  toStr(str, value);
1788 
1789  return stream << str;
1790 }
1791 
1792 /// Serializes the object into FIX presentation.
1793 inline
1794 void
1796  std::string& str,
1797  QuoteTyp::Enum value)
1798 {
1799  toStr(
1800  str,
1801  static_cast<QuoteTyp::Base>(value));
1802 }
1803 
1804 
1805 /// Serializes into a string.
1807 void
1808 toStr(
1809  std::string& str,
1810  RFQSide::Enum value);
1811 
1812 
1813 /// Serializes into a string.
1814 inline std::string toStr(RFQSide::Enum value)
1815 {
1816  std::string str;
1817 
1818  toStr(str, value);
1819 
1820  return str;
1821 }
1822 
1823 /// Serializes into a stream.
1824 inline
1825 std::ostream&
1827  std::ostream& stream,
1828  RFQSide::Enum value)
1829 {
1830  std::string str;
1831 
1832  toStr(str, value);
1833 
1834  return stream << str;
1835 }
1836 
1837 /// Serializes the object into FIX presentation.
1838 inline
1839 void
1841  std::string& str,
1842  RFQSide::Enum value)
1843 {
1844  toStr(
1845  str,
1846  static_cast<RFQSide::Base>(value));
1847 }
1848 
1849 
1850 /// Serializes into a string.
1852 void
1853 toStr(
1854  std::string& str,
1855  ReqResult::Enum value);
1856 
1857 
1858 /// Serializes into a string.
1859 inline std::string toStr(ReqResult::Enum value)
1860 {
1861  std::string str;
1862 
1863  toStr(str, value);
1864 
1865  return str;
1866 }
1867 
1868 /// Serializes into a stream.
1869 inline
1870 std::ostream&
1872  std::ostream& stream,
1873  ReqResult::Enum value)
1874 {
1875  std::string str;
1876 
1877  toStr(str, value);
1878 
1879  return stream << str;
1880 }
1881 
1882 /// Serializes the object into FIX presentation.
1883 inline
1884 void
1886  std::string& str,
1887  ReqResult::Enum value)
1888 {
1889  toStr(
1890  str,
1891  static_cast<ReqResult::Base>(value));
1892 }
1893 
1894 
1895 /// Serializes into a string.
1897 void
1898 toStr(
1899  std::string& str,
1900  SLEDS::Enum value);
1901 
1902 
1903 /// Serializes into a string.
1904 inline std::string toStr(SLEDS::Enum value)
1905 {
1906  std::string str;
1907 
1908  toStr(str, value);
1909 
1910  return str;
1911 }
1912 
1913 /// Serializes into a stream.
1914 inline
1915 std::ostream&
1917  std::ostream& stream,
1918  SLEDS::Enum value)
1919 {
1920  std::string str;
1921 
1922  toStr(str, value);
1923 
1924  return stream << str;
1925 }
1926 
1927 /// Serializes the object into FIX presentation.
1928 inline
1929 void
1931  std::string& str,
1932  SLEDS::Enum value)
1933 {
1934  toStr(
1935  str,
1936  static_cast<SLEDS::Base>(value));
1937 }
1938 
1939 
1940 /// Serializes into a string.
1942 void
1943 toStr(
1944  std::string& str,
1945  SMPI::Enum value);
1946 
1947 
1948 /// Serializes into a string.
1949 inline std::string toStr(SMPI::Enum value)
1950 {
1951  std::string str;
1952 
1953  toStr(str, value);
1954 
1955  return str;
1956 }
1957 
1958 /// Serializes into a stream.
1959 inline
1960 std::ostream&
1962  std::ostream& stream,
1963  SMPI::Enum value)
1964 {
1965  std::string str;
1966 
1967  toStr(str, value);
1968 
1969  return stream << str;
1970 }
1971 
1972 /// Serializes the object into FIX presentation.
1973 inline
1974 void
1976  std::string& str,
1977  SMPI::Enum value)
1978 {
1979  toStr(
1980  str,
1981  static_cast<SMPI::Base>(value));
1982 }
1983 
1984 
1985 /// Serializes into a string.
1987 void
1988 toStr(
1989  std::string& str,
1990  SecRspTyp::Enum value);
1991 
1992 
1993 /// Serializes into a string.
1994 inline std::string toStr(SecRspTyp::Enum value)
1995 {
1996  std::string str;
1997 
1998  toStr(str, value);
1999 
2000  return str;
2001 }
2002 
2003 /// Serializes into a stream.
2004 inline
2005 std::ostream&
2007  std::ostream& stream,
2008  SecRspTyp::Enum value)
2009 {
2010  std::string str;
2011 
2012  toStr(str, value);
2013 
2014  return stream << str;
2015 }
2016 
2017 /// Serializes the object into FIX presentation.
2018 inline
2019 void
2021  std::string& str,
2022  SecRspTyp::Enum value)
2023 {
2024  toStr(
2025  str,
2026  static_cast<SecRspTyp::Base>(value));
2027 }
2028 
2029 
2030 /// Serializes into a string.
2032 void
2033 toStr(
2034  std::string& str,
2035  ShortSaleType::Enum value);
2036 
2037 
2038 /// Serializes into a string.
2039 inline
2040 std::string
2042  ShortSaleType::Enum value)
2043 {
2044  std::string str;
2045 
2046  toStr(str, value);
2047 
2048  return str;
2049 }
2050 
2051 /// Serializes into a stream.
2052 inline
2053 std::ostream&
2055  std::ostream& stream,
2056  ShortSaleType::Enum value)
2057 {
2058  std::string str;
2059 
2060  toStr(str, value);
2061 
2062  return stream << str;
2063 }
2064 
2065 /// Serializes the object into FIX presentation.
2066 inline
2067 void
2069  std::string& str,
2070  ShortSaleType::Enum value)
2071 {
2072  toStr(
2073  str,
2074  static_cast<ShortSaleType::Base>(value));
2075 }
2076 
2077 
2078 /// Serializes into a string.
2080 void
2081 toStr(
2082  std::string& str,
2083  SideNULL::Enum value);
2084 
2085 
2086 /// Serializes into a string.
2087 inline std::string toStr(SideNULL::Enum value)
2088 {
2089  std::string str;
2090 
2091  toStr(str, value);
2092 
2093  return str;
2094 }
2095 
2096 /// Serializes into a stream.
2097 inline
2098 std::ostream&
2100  std::ostream& stream,
2101  SideNULL::Enum value)
2102 {
2103  std::string str;
2104 
2105  toStr(str, value);
2106 
2107  return stream << str;
2108 }
2109 
2110 /// Serializes the object into FIX presentation.
2111 inline
2112 void
2114  std::string& str,
2115  SideNULL::Enum value)
2116 {
2117  toStr(
2118  str,
2119  static_cast<SideNULL::Base>(value));
2120 }
2121 
2122 
2123 /// Serializes into a string.
2125 void
2126 toStr(
2127  std::string& str,
2128  SideReq::Enum value);
2129 
2130 
2131 /// Serializes into a string.
2132 inline std::string toStr(SideReq::Enum value)
2133 {
2134  std::string str;
2135 
2136  toStr(str, value);
2137 
2138  return str;
2139 }
2140 
2141 /// Serializes into a stream.
2142 inline
2143 std::ostream&
2145  std::ostream& stream,
2146  SideReq::Enum value)
2147 {
2148  std::string str;
2149 
2150  toStr(str, value);
2151 
2152  return stream << str;
2153 }
2154 
2155 /// Serializes the object into FIX presentation.
2156 inline
2157 void
2159  std::string& str,
2160  SideReq::Enum value)
2161 {
2162  toStr(
2163  str,
2164  static_cast<SideReq::Base>(value));
2165 }
2166 
2167 
2168 /// Serializes into a string.
2170 void
2171 toStr(
2172  std::string& str,
2173  SideTimeInForce::Enum value);
2174 
2175 
2176 /// Serializes into a string.
2177 inline
2178 std::string
2180  SideTimeInForce::Enum value)
2181 {
2182  std::string str;
2183 
2184  toStr(str, value);
2185 
2186  return str;
2187 }
2188 
2189 /// Serializes into a stream.
2190 inline
2191 std::ostream&
2193  std::ostream& stream,
2194  SideTimeInForce::Enum value)
2195 {
2196  std::string str;
2197 
2198  toStr(str, value);
2199 
2200  return stream << str;
2201 }
2202 
2203 /// Serializes the object into FIX presentation.
2204 inline
2205 void
2207  std::string& str,
2208  SideTimeInForce::Enum value)
2209 {
2210  toStr(
2211  str,
2212  static_cast<SideTimeInForce::Base>(value));
2213 }
2214 
2215 
2216 /// Serializes into a string.
2218 void
2219 toStr(
2220  std::string& str,
2221  SplitMsg::Enum value);
2222 
2223 
2224 /// Serializes into a string.
2225 inline std::string toStr(SplitMsg::Enum value)
2226 {
2227  std::string str;
2228 
2229  toStr(str, value);
2230 
2231  return str;
2232 }
2233 
2234 /// Serializes into a stream.
2235 inline
2236 std::ostream&
2238  std::ostream& stream,
2239  SplitMsg::Enum value)
2240 {
2241  std::string str;
2242 
2243  toStr(str, value);
2244 
2245  return stream << str;
2246 }
2247 
2248 /// Serializes the object into FIX presentation.
2249 inline
2250 void
2252  std::string& str,
2253  SplitMsg::Enum value)
2254 {
2255  toStr(
2256  str,
2257  static_cast<SplitMsg::Base>(value));
2258 }
2259 
2260 
2261 /// Serializes into a string.
2263 void
2264 toStr(
2265  std::string& str,
2266  TimeInForce::Enum value);
2267 
2268 
2269 /// Serializes into a string.
2270 inline std::string toStr(TimeInForce::Enum value)
2271 {
2272  std::string str;
2273 
2274  toStr(str, value);
2275 
2276  return str;
2277 }
2278 
2279 /// Serializes into a stream.
2280 inline
2281 std::ostream&
2283  std::ostream& stream,
2284  TimeInForce::Enum value)
2285 {
2286  std::string str;
2287 
2288  toStr(str, value);
2289 
2290  return stream << str;
2291 }
2292 
2293 /// Serializes the object into FIX presentation.
2294 inline
2295 void
2297  std::string& str,
2298  TimeInForce::Enum value)
2299 {
2300  toStr(
2301  str,
2302  static_cast<TimeInForce::Base>(value));
2303 }
2304 
2305 
2306 /// Serializes into a string.
2308 void
2309 toStr(
2310  std::string& str,
2311  TradeAddendum::Enum value);
2312 
2313 
2314 /// Serializes into a string.
2315 inline
2316 std::string
2318  TradeAddendum::Enum value)
2319 {
2320  std::string str;
2321 
2322  toStr(str, value);
2323 
2324  return str;
2325 }
2326 
2327 /// Serializes into a stream.
2328 inline
2329 std::ostream&
2331  std::ostream& stream,
2332  TradeAddendum::Enum value)
2333 {
2334  std::string str;
2335 
2336  toStr(str, value);
2337 
2338  return stream << str;
2339 }
2340 
2341 /// Serializes the object into FIX presentation.
2342 inline
2343 void
2345  std::string& str,
2346  TradeAddendum::Enum value)
2347 {
2348  toStr(
2349  str,
2350  static_cast<TradeAddendum::Base>(value));
2351 }
2352 
2353 
2354 /// Serializes into a string.
2356 void
2357 toStr(
2358  std::string& str,
2359  ExecInst set);
2360 
2361 
2362 /// Serializes into a string.
2363 inline std::string toStr(ExecInst set)
2364 {
2365  std::string str;
2366 
2367  toStr(str, set);
2368 
2369  return str;
2370 }
2371 
2372 /// Serializes into a stream.
2373 inline
2374 std::ostream&
2376  std::ostream& stream,
2377  ExecInst set)
2378 {
2379  std::string str;
2380 
2381  toStr(str, set);
2382 
2383  return stream << str;
2384 }
2385 
2386 /// Serializes the object into FIX presentation.
2387 inline
2388 void
2390  std::string& str,
2391  ExecInst set)
2392 {
2393  toStr(str, set.bits());
2394 }
2395 
2396 
2397 /// Serializes into a string.
2399 void
2400 toStr(
2401  std::string& str,
2402  const MaturityMonthYear& obj);
2403 
2404 
2405 /// Serializes into a string.
2406 inline
2407 std::string
2409  const MaturityMonthYear& obj)
2410 {
2411  std::string str;
2412 
2413  toStr(str, obj);
2414 
2415  return str;
2416 }
2417 
2418 /// Serializes into a stream.
2419 inline
2420 std::ostream&
2422  std::ostream& stream,
2423  const MaturityMonthYear& obj)
2424 {
2425  std::string str;
2426 
2427  toStr(str, obj);
2428 
2429  return stream << str;
2430 }
2431 
2432 
2433 inline std::string ExecInst::toString() const
2434 {
2435  return toStr(*this);
2436 }
2437 
2438 inline std::string MaturityMonthYear::toString() const
2439 {
2440  return toStr(*this);
2441 }
2442 
2443 inline std::string AvgPxInd::toString(AvgPxInd::Enum value)
2444 {
2445  return toStr(value);
2446 }
2447 
2448 inline std::string BooleanFlag::toString(BooleanFlag::Enum value)
2449 {
2450  return toStr(value);
2451 }
2452 
2453 inline std::string BooleanNULL::toString(BooleanNULL::Enum value)
2454 {
2455  return toStr(value);
2456 }
2457 
2458 inline
2459 std::string
2460 ClearingAcctType::toString(
2461  ClearingAcctType::Enum value)
2462 {
2463  return toStr(value);
2464 }
2465 
2466 inline std::string CmtaGiveUpCD::toString(CmtaGiveUpCD::Enum value)
2467 {
2468  return toStr(value);
2469 }
2470 
2471 inline
2472 std::string
2473 CustOrdHandlInst::toString(
2474  CustOrdHandlInst::Enum value)
2475 {
2476  return toStr(value);
2477 }
2478 
2479 inline
2480 std::string
2481 CustOrderCapacity::toString(
2483 {
2484  return toStr(value);
2485 }
2486 
2487 inline std::string DKReason::toString(DKReason::Enum value)
2488 {
2489  return toStr(value);
2490 }
2491 
2492 inline
2493 std::string
2494 ExecAckStatus::toString(
2495  ExecAckStatus::Enum value)
2496 {
2497  return toStr(value);
2498 }
2499 
2500 inline std::string ExecMode::toString(ExecMode::Enum value)
2501 {
2502  return toStr(value);
2503 }
2504 
2505 inline std::string ExecReason::toString(ExecReason::Enum value)
2506 {
2507  return toStr(value);
2508 }
2509 
2510 inline
2511 std::string
2512 ExecTypTrdCxl::toString(
2513  ExecTypTrdCxl::Enum value)
2514 {
2515  return toStr(value);
2516 }
2517 
2518 inline std::string ExpCycle::toString(ExpCycle::Enum value)
2519 {
2520  return toStr(value);
2521 }
2522 
2523 inline std::string FTI::toString(FTI::Enum value)
2524 {
2525  return toStr(value);
2526 }
2527 
2528 inline
2529 std::string
2530 KeepAliveLapsed::toString(
2531  KeepAliveLapsed::Enum value)
2532 {
2533  return toStr(value);
2534 }
2535 
2536 inline std::string ListUpdAct::toString(ListUpdAct::Enum value)
2537 {
2538  return toStr(value);
2539 }
2540 
2541 inline std::string ManualOrdInd::toString(ManualOrdInd::Enum value)
2542 {
2543  return toStr(value);
2544 }
2545 
2546 inline
2547 std::string
2548 ManualOrdIndReq::toString(
2549  ManualOrdIndReq::Enum value)
2550 {
2551  return toStr(value);
2552 }
2553 
2554 inline
2555 std::string
2556 MassActionOrdTyp::toString(
2557  MassActionOrdTyp::Enum value)
2558 {
2559  return toStr(value);
2560 }
2561 
2562 inline
2563 std::string
2564 MassActionResponse::toString(
2566 {
2567  return toStr(value);
2568 }
2569 
2570 inline
2571 std::string
2572 MassActionScope::toString(
2573  MassActionScope::Enum value)
2574 {
2575  return toStr(value);
2576 }
2577 
2578 inline
2579 std::string
2580 MassCancelTIF::toString(
2581  MassCancelTIF::Enum value)
2582 {
2583  return toStr(value);
2584 }
2585 
2586 inline
2587 std::string
2588 MassCxlReqTyp::toString(
2589  MassCxlReqTyp::Enum value)
2590 {
2591  return toStr(value);
2592 }
2593 
2594 inline
2595 std::string
2596 MassStatusOrdTyp::toString(
2597  MassStatusOrdTyp::Enum value)
2598 {
2599  return toStr(value);
2600 }
2601 
2602 inline
2603 std::string
2604 MassStatusReqTyp::toString(
2605  MassStatusReqTyp::Enum value)
2606 {
2607  return toStr(value);
2608 }
2609 
2610 inline
2611 std::string
2612 MassStatusTIF::toString(
2613  MassStatusTIF::Enum value)
2614 {
2615  return toStr(value);
2616 }
2617 
2618 inline
2619 std::string
2620 OFMOverrideReq::toString(
2621  OFMOverrideReq::Enum value)
2622 {
2623  return toStr(value);
2624 }
2625 
2626 inline std::string OrdStatusTrd::toString(OrdStatusTrd::Enum value)
2627 {
2628  return toStr(value);
2629 }
2630 
2631 inline
2632 std::string
2633 OrdStatusTrdCxl::toString(
2634  OrdStatusTrdCxl::Enum value)
2635 {
2636  return toStr(value);
2637 }
2638 
2639 inline
2640 std::string
2641 OrderEventType::toString(
2642  OrderEventType::Enum value)
2643 {
2644  return toStr(value);
2645 }
2646 
2647 inline std::string OrderStatus::toString(OrderStatus::Enum value)
2648 {
2649  return toStr(value);
2650 }
2651 
2652 inline std::string OrderType::toString(OrderType::Enum value)
2653 {
2654  return toStr(value);
2655 }
2656 
2657 inline std::string OrderTypeReq::toString(OrderTypeReq::Enum value)
2658 {
2659  return toStr(value);
2660 }
2661 
2662 inline
2663 std::string
2664 PartyDetailRole::toString(
2665  PartyDetailRole::Enum value)
2666 {
2667  return toStr(value);
2668 }
2669 
2670 inline
2671 std::string
2672 QuoteAckStatus::toString(
2673  QuoteAckStatus::Enum value)
2674 {
2675  return toStr(value);
2676 }
2677 
2678 inline
2679 std::string
2680 QuoteCxlStatus::toString(
2681  QuoteCxlStatus::Enum value)
2682 {
2683  return toStr(value);
2684 }
2685 
2686 inline std::string QuoteCxlTyp::toString(QuoteCxlTyp::Enum value)
2687 {
2688  return toStr(value);
2689 }
2690 
2691 inline std::string QuoteTyp::toString(QuoteTyp::Enum value)
2692 {
2693  return toStr(value);
2694 }
2695 
2696 inline std::string RFQSide::toString(RFQSide::Enum value)
2697 {
2698  return toStr(value);
2699 }
2700 
2701 inline std::string ReqResult::toString(ReqResult::Enum value)
2702 {
2703  return toStr(value);
2704 }
2705 
2706 inline std::string SLEDS::toString(SLEDS::Enum value)
2707 {
2708  return toStr(value);
2709 }
2710 
2711 inline std::string SMPI::toString(SMPI::Enum value)
2712 {
2713  return toStr(value);
2714 }
2715 
2716 inline std::string SecRspTyp::toString(SecRspTyp::Enum value)
2717 {
2718  return toStr(value);
2719 }
2720 
2721 inline
2722 std::string
2723 ShortSaleType::toString(
2724  ShortSaleType::Enum value)
2725 {
2726  return toStr(value);
2727 }
2728 
2729 inline std::string SideNULL::toString(SideNULL::Enum value)
2730 {
2731  return toStr(value);
2732 }
2733 
2734 inline std::string SideReq::toString(SideReq::Enum value)
2735 {
2736  return toStr(value);
2737 }
2738 
2739 inline
2740 std::string
2741 SideTimeInForce::toString(
2742  SideTimeInForce::Enum value)
2743 {
2744  return toStr(value);
2745 }
2746 
2747 inline std::string SplitMsg::toString(SplitMsg::Enum value)
2748 {
2749  return toStr(value);
2750 }
2751 
2752 inline std::string TimeInForce::toString(TimeInForce::Enum value)
2753 {
2754  return toStr(value);
2755 }
2756 
2757 inline
2758 std::string
2759 TradeAddendum::toString(
2760  TradeAddendum::Enum value)
2761 {
2762  return toStr(value);
2763 }
2764 
std::ostream & operator<<(std::ostream &stream, const MaturityMonthYear &obj)
Serializes into a stream.
#define ONIXS_ILINK3_MESSAGING_NAMESPACE_END
Definition: ABI.h:144
#define ONIXS_ILINK3_EXPORTED
Definition: Compiler.h:162
std::string toStr(const MaturityMonthYear &obj)
Serializes into a string.
#define ONIXS_ILINK3_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:140
void toFix(std::string &str, ExecInst set)
Serializes the object into FIX presentation.