OnixS C++ CME Market Data Handler  5.4.0
API documentation
Messages.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 <cassert>
24 #include <stdexcept>
25 
28 
30 
31 /// MDInstrumentDefinitionFixedIncome.
35 {
36  /// Message template ID from SBE schema.
37  enum { TemplateId = 57 };
38 
39  /// Number of repeating EventType entries..
40  /// Entry of EventsEntry repeating group.
43  <
45  >
46  {
47  /// Aliases base class type.
48  typedef
50  <
52  >
54 
55  /// Initializes blank instance.
57  {
58  }
59 
60  /// Initializes instance of given
61  /// version over given memory block.
63  const void* data,
64  EncodedLength length,
65  SchemaVersion version)
66  : Base(data, length, version)
67  {
68  if (length < blockLength(version))
69  throwBadBinaryData(className());
70  }
71 
72  /// Code to represent the type of event.
74  {
75  const BlockLength offset = 0;
76 
77  return enumeration<EventType>(offset);
78  }
79 
80  /// Date and Time of instrument Activation or Expiration event
81  /// sent as number of nanoseconds since Unix epoch.
83  {
84  const BlockLength offset = 1;
85 
86  return ordinary<Timestamp>(offset);
87  }
88 
89  /// Returns size of entry body in bytes
90  /// for given version of message template.
93  {
94  return 9;
95  }
96 
97  /// Entity class name.
99  static const Char* className()
100  {
101  return "InstrumentDefinitionFixedIncome57.EventsEntry";
102  }
103  };
104 
105  /// Repeating group containing EventsEntry entries.
106  typedef
109 
110  /// Number of repeating FeedType repeating group entries..
111  /// Entry of FeedTypesEntry repeating group.
114  <
116  >
117  {
118  /// Aliases base class type.
119  typedef
121  <
123  >
125 
126  /// Initializes blank instance.
128  {
129  }
130 
131  /// Initializes instance of given
132  /// version over given memory block.
134  const void* data,
135  EncodedLength length,
136  SchemaVersion version)
137  : Base(data, length, version)
138  {
139  if (length < blockLength(version))
140  throwBadBinaryData(className());
141  }
142 
143  /// Describes a class of service for a given data feed. GBX-
144  /// Real Book, GBI-Implied Book.
145  StrRef feedType() const
146  {
147  const BlockLength offset = 0;
148  const BlockLength length = 3;
149 
150  return fixedStr<length>(offset);
151  }
152 
153  /// book depth.
155  {
156  const BlockLength offset = 3;
157 
158  return ordinary<Int8>(offset);
159  }
160 
161  /// Returns size of entry body in bytes
162  /// for given version of message template.
165  {
166  return 4;
167  }
168 
169  /// Entity class name.
171  static const Char* className()
172  {
173  return "InstrumentDefinitionFixedIncome57.FeedTypesEntry";
174  }
175  };
176 
177  /// Repeating group containing FeedTypesEntry entries.
178  typedef
181 
182  /// Number of repeating InstrAttribType entries..
183  /// Entry of InstAttribEntry repeating group.
186  <
188  >
189  {
190  /// Aliases base class type.
191  typedef
193  <
195  >
197 
198  /// Initializes blank instance.
200  {
201  }
202 
203  /// Initializes instance of given
204  /// version over given memory block.
206  const void* data,
207  EncodedLength length,
208  SchemaVersion version)
209  : Base(data, length, version)
210  {
211  if (length < blockLength(version))
212  throwBadBinaryData(className());
213  }
214 
215  /// Instrument eligibility attributes.
217  {
218  return InstAttribType();
219  }
220 
221  /// Bitmap field of 32 Boolean type instrument eligibility
222  /// flags.
224  {
225  const BlockLength offset = 0;
226 
227  return ordinary<InstAttribValue>(offset);
228  }
229 
230  /// Returns size of entry body in bytes
231  /// for given version of message template.
234  {
235  return 4;
236  }
237 
238  /// Entity class name.
240  static const Char* className()
241  {
242  return "InstrumentDefinitionFixedIncome57.InstAttribEntry";
243  }
244  };
245 
246  /// Repeating group containing InstAttribEntry entries.
247  typedef
250 
251  /// Number of entries.
252  /// Entry of LotTypeRulesEntry repeating group.
255  <
257  >
258  {
259  /// Aliases base class type.
260  typedef
262  <
264  >
266 
267  /// Initializes blank instance.
269  {
270  }
271 
272  /// Initializes instance of given
273  /// version over given memory block.
275  const void* data,
276  EncodedLength length,
277  SchemaVersion version)
278  : Base(data, length, version)
279  {
280  if (length < blockLength(version))
281  throwBadBinaryData(className());
282  }
283 
284  /// This tag is required to interpret the value in tag
285  /// 1231-MinLotSize.
286  Int8 lotType() const
287  {
288  const BlockLength offset = 0;
289 
290  return ordinary<Int8>(offset);
291  }
292 
293  /// Minimum quantity accepted for order entry. If tag
294  /// 1093-LotType=4, this value is the minimum quantity for
295  /// order entry expressed in the applicable units, specified
296  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
297  /// 1093-LotType= 5, this value represents order qty increment.
298  bool minLotSize(Decimal& value) const
299  {
300  typedef NullDecimalQty Null;
301 
302  const BlockLength offset = 1;
303 
304  return decimal(value, offset, Null());
305  }
306 
307  /// Returns size of entry body in bytes
308  /// for given version of message template.
311  {
312  return 5;
313  }
314 
315  /// Entity class name.
317  static const Char* className()
318  {
319  return "InstrumentDefinitionFixedIncome57.LotTypeRulesEntry";
320  }
321  };
322 
323  /// Repeating group containing LotTypeRulesEntry entries.
324  typedef
327 
328  /// Initializes blank instance.
330  {
331  }
332 
333  /// Initializes instance over given memory block.
335  const void* data,
336  EncodedLength length)
337  : BinaryMessage(data, length)
338  {
339  assert(TemplateId == templateId());
340 
341  const SchemaVersion current = version();
342  const SchemaVersion since = 10;
343 
344  if (current < since)
346  className(), current, since);
347 
348  if (length < blockLength(current))
349  throwBadBinaryData(className());
350  }
351 
352  /// Bitmap field of eight Boolean type indicators reflecting
353  /// the end of updates for a given Globex event.
355  {
356  const BlockLength offset = 0;
357 
358  return ordinary<MatchEventIndicator>(offset);
359  }
360 
361  /// Total number of instruments in the Replay loop. Used on
362  /// Replay Feed only.
364  {
365  typedef NullUInt32 Null;
366 
367  const BlockLength offset = 1;
368 
369  return ordinary(value, offset, Null());
370  }
371 
372  /// Last Security update action on Incremental feed, 'D' or
373  /// 'M' is used when a mid-week deletion or modification (i.e.
374  /// extension) occurs.
377  {
378  const BlockLength offset = 5;
379 
380  return enumeration<SecurityUpdateAction>(offset);
381  }
382 
383  /// Timestamp of when the instrument was last added, modified
384  /// or deleted.
386  {
387  const BlockLength offset = 6;
388 
389  return ordinary<Timestamp>(offset);
390  }
391 
392  /// Identifies the current market state of the instrument.
393  bool
396  {
397  typedef NullUInt8 Null;
398 
399  const BlockLength offset = 14;
400 
401  return enumeration<SecurityTradingStatus>(value, offset, Null());
402  }
403 
404  /// MD channel ID as defined in the XML Configuration file.
405  Int16 applId() const
406  {
407  const BlockLength offset = 15;
408 
409  return ordinary<Int16>(offset);
410  }
411 
412  /// Identifies the market segment for all CME Globex
413  /// instruments.
415  {
416  const BlockLength offset = 17;
417 
418  return ordinary<UInt8>(offset);
419  }
420 
421  /// Indicates the product complex.
423  {
424  const BlockLength offset = 18;
425 
426  return ordinary<UInt8>(offset);
427  }
428 
429  /// Exchange used to identify a security.
431  {
432  const BlockLength offset = 19;
433  const BlockLength length = 4;
434 
435  return fixedStr<length>(offset);
436  }
437 
438  /// Security Group Code.
440  {
441  const BlockLength offset = 23;
442  const BlockLength length = 6;
443 
444  return fixedStr<length>(offset);
445  }
446 
447  /// The underlying asset code also known as Product Code.
448  StrRef asset() const
449  {
450  const BlockLength offset = 29;
451  const BlockLength length = 6;
452 
453  return fixedStr<length>(offset);
454  }
455 
456  /// Instrument Name or Symbol.
457  StrRef symbol() const
458  {
459  const BlockLength offset = 35;
460  const BlockLength length = 20;
461 
462  return fixedStr<length>(offset);
463  }
464 
465  /// Unique instrument ID.
467  {
468  const BlockLength offset = 55;
469 
470  return ordinary<Int32>(offset);
471  }
472 
473  /// Identifies class or source of Tag 48-SecurityID value.
475  {
476  return SecurityIDSource();
477  }
478 
479  /// Security Type.
481  {
482  const BlockLength offset = 59;
483  const BlockLength length = 6;
484 
485  return fixedStr<length>(offset);
486  }
487 
488  /// ISO standard instrument categorization code.
489  StrRef cfiCode() const
490  {
491  const BlockLength offset = 65;
492  const BlockLength length = 6;
493 
494  return fixedStr<length>(offset);
495  }
496 
497  /// Identifies the currency used for price.
498  StrRef currency() const
499  {
500  const BlockLength offset = 71;
501  const BlockLength length = 3;
502 
503  return fixedStr<length>(offset);
504  }
505 
506  /// Identifies currency used for settlement, if different from
507  /// trade price currency.
509  {
510  const BlockLength offset = 74;
511  const BlockLength length = 3;
512 
513  return fixedStr<length>(offset);
514  }
515 
516  /// Matching Algorithm.
518  {
519  const BlockLength offset = 77;
520 
521  return ordinary<CHAR>(offset);
522  }
523 
524  /// The minimum trading volume for a security.
526  {
527  const BlockLength offset = 78;
528 
529  return ordinary<UInt32>(offset);
530  }
531 
532  /// The maximum trading volume for a security.
534  {
535  const BlockLength offset = 82;
536 
537  return ordinary<UInt32>(offset);
538  }
539 
540  /// Minimum constant tick for the instrument, sent only if
541  /// instrument is non-VTT (Variable Tick table) eligible.
543  {
544  typedef NullPRICE9 Null;
545 
546  const BlockLength offset = 86;
547 
548  return decimal(value, offset, Null());
549  }
550 
551  /// Contains the multiplier to convert the CME Globex display
552  /// price to the conventional price.
554  {
555  const BlockLength offset = 94;
556 
557  return decimal<Decimal9>(offset);
558  }
559 
560  /// Price Denominator of Main Fraction.
561  bool mainFraction(UInt8& value) const
562  {
563  typedef NullUInt8 Null;
564 
565  const BlockLength offset = 102;
566 
567  return ordinary(value, offset, Null());
568  }
569 
570  /// Price Denominator of Sub Fraction.
571  bool subFraction(UInt8& value) const
572  {
573  typedef NullUInt8 Null;
574 
575  const BlockLength offset = 103;
576 
577  return ordinary(value, offset, Null());
578  }
579 
580  /// Number of Decimals in Displayed Price.
582  {
583  typedef NullUInt8 Null;
584 
585  const BlockLength offset = 104;
586 
587  return ordinary(value, offset, Null());
588  }
589 
590  /// Unit of measure for the products' original contract size.
591  /// This will be populated for all products listed on CME
592  /// Globex.
594  {
595  const BlockLength offset = 105;
596  const BlockLength length = 30;
597 
598  return fixedStr<length>(offset);
599  }
600 
601  /// This field contains the contract size for each instrument.
602  /// Use in combination with tag 996-UnitofMeasure.
604  {
605  typedef NullDecimal9 Null;
606 
607  const BlockLength offset = 135;
608 
609  return decimal(value, offset, Null());
610  }
611 
612  /// Trading Reference Price.
614  {
615  typedef NullPRICE9 Null;
616 
617  const BlockLength offset = 143;
618 
619  return decimal(value, offset, Null());
620  }
621 
622  /// Indicates session date corresponding to the reference
623  /// price in tag 1150-TradingReferencePrice.
625  {
626  typedef NullLocalMktDate Null;
627  typedef LocalMktDate FieldValue;
628 
629  const BlockLength offset = 151;
630 
631  FieldValue fieldValue;
632 
633  if (ordinary(fieldValue, offset, Null()))
634  {
635  value = localMktDateToTimestamp(fieldValue);
636  return true;
637  }
638  return false;
639  }
640 
641  /// Allowable high limit price for the trading day.
643  {
644  typedef NullPRICE9 Null;
645 
646  const BlockLength offset = 153;
647 
648  return decimal(value, offset, Null());
649  }
650 
651  /// Allowable low limit price for the trading day.
653  {
654  typedef NullPRICE9 Null;
655 
656  const BlockLength offset = 161;
657 
658  return decimal(value, offset, Null());
659  }
660 
661  /// Differential value for price banding.
663  {
664  typedef NullPRICE9 Null;
665 
666  const BlockLength offset = 169;
667 
668  return decimal(value, offset, Null());
669  }
670 
671  /// Monetary value equivalent to the minimum price
672  /// fluctuation.
674  {
675  typedef NullPRICE9 Null;
676 
677  const BlockLength offset = 177;
678 
679  return decimal(value, offset, Null());
680  }
681 
682  /// Issue Date.
683  bool issueDate(Timestamp& value) const
684  {
685  typedef NullLocalMktDate Null;
686  typedef LocalMktDate FieldValue;
687 
688  const BlockLength offset = 185;
689 
690  FieldValue fieldValue;
691 
692  if (ordinary(fieldValue, offset, Null()))
693  {
694  value = localMktDateToTimestamp(fieldValue);
695  return true;
696  }
697  return false;
698  }
699 
700  /// Dated Date.
701  bool datedDate(Timestamp& value) const
702  {
703  typedef NullLocalMktDate Null;
704  typedef LocalMktDate FieldValue;
705 
706  const BlockLength offset = 187;
707 
708  FieldValue fieldValue;
709 
710  if (ordinary(fieldValue, offset, Null()))
711  {
712  value = localMktDateToTimestamp(fieldValue);
713  return true;
714  }
715  return false;
716  }
717 
718  /// Maturity Date.
720  {
721  typedef NullLocalMktDate Null;
722  typedef LocalMktDate FieldValue;
723 
724  const BlockLength offset = 189;
725 
726  FieldValue fieldValue;
727 
728  if (ordinary(fieldValue, offset, Null()))
729  {
730  value = localMktDateToTimestamp(fieldValue);
731  return true;
732  }
733  return false;
734  }
735 
736  /// The rate of interest that, when multiplied by the
737  /// principal, par value, or face value of a bond, provides
738  /// the currency amount of the periodic interest payment.
739  bool couponRate(Decimal& value) const
740  {
741  typedef NullDecimal9 Null;
742 
743  const BlockLength offset = 191;
744 
745  return decimal(value, offset, Null());
746  }
747 
748  /// Par value.
749  bool parValue(Decimal& value) const
750  {
751  typedef NullPRICE9 Null;
752 
753  const BlockLength offset = 199;
754 
755  return decimal(value, offset, Null());
756  }
757 
758  /// Time unit associated with the frequency of the bond's
759  /// coupon payment.
761  {
762  const BlockLength offset = 207;
763  const BlockLength length = 3;
764  const SchemaVersion since = 10;
765 
766  return fixedStr<length>(offset, since);
767  }
768 
769  /// Time unit multiplier for the frequency of the bond's
770  /// coupon payment.
772  {
773  typedef NullUInt16 Null;
774 
775  const BlockLength offset = 210;
776 
777  return ordinary(value, offset, Null());
778  }
779 
780  /// The day count convention used in interest calculations for
781  /// a bond or an interest bearing security.
783  {
784  const BlockLength offset = 212;
785  const BlockLength length = 20;
786  const SchemaVersion since = 10;
787 
788  return fixedStr<length>(offset, since);
789  }
790 
791  /// Country of Origin, ISO alpha-2 country code.
793  {
794  const BlockLength offset = 232;
795  const BlockLength length = 2;
796  const SchemaVersion since = 10;
797 
798  return fixedStr<length>(offset, since);
799  }
800 
801  /// Name of security issuer or the Legal Entity Identifier
802  /// (LEI - the International ISO standard 17442).
803  StrRef issuer() const
804  {
805  const BlockLength offset = 234;
806  const BlockLength length = 25;
807  const SchemaVersion since = 10;
808 
809  return fixedStr<length>(offset, since);
810  }
811 
812  /// Long name of the instrument.
814  {
815  const BlockLength offset = 259;
816  const BlockLength length = 35;
817  const SchemaVersion since = 10;
818 
819  return fixedStr<length>(offset, since);
820  }
821 
822  /// Expanded instrument description. Will contain either ISIN
823  /// or CUSIP.
825  {
826  const BlockLength offset = 294;
827  const BlockLength length = 12;
828  const SchemaVersion since = 10;
829 
830  return fixedStr<length>(offset, since);
831  }
832 
833  /// Identifies class or source of the SecurityAltID (455)
834  /// value.
835  bool
838  {
839  typedef NullUInt8 Null;
840 
841  const BlockLength offset = 306;
842  const SchemaVersion since = 10;
843 
844  return enumeration<SecurityAltIDSource>(value, offset, Null(), since);
845  }
846 
847  /// Price quotation method.
849  {
850  const BlockLength offset = 307;
851  const BlockLength length = 5;
852  const SchemaVersion since = 10;
853 
854  return fixedStr<length>(offset, since);
855  }
856 
857  /// Clearing organization.
859  {
860  const BlockLength offset = 312;
861  const BlockLength length = 5;
862  const SchemaVersion since = 10;
863 
864  return fixedStr<length>(offset, since);
865  }
866 
867  /// User-defined Instrument flag.
869  {
870  const BlockLength offset = 317;
871 
872  return ordinary<UserDefinedInstrument>(offset);
873  }
874 
875  /// Risk Set identifies the list of instruments sharing credit
876  /// limits set up.
877  StrRef riskSet() const
878  {
879  const BlockLength offset = 318;
880  const BlockLength length = 6;
881  const SchemaVersion since = 10;
882 
883  return fixedStr<length>(offset, since);
884  }
885 
886  /// Market Set defines the bilateral relationship and Self
887  /// Match Prevention configuration for eligible markets.
889  {
890  const BlockLength offset = 324;
891  const BlockLength length = 6;
892  const SchemaVersion since = 10;
893 
894  return fixedStr<length>(offset, since);
895  }
896 
897  /// External unique instrument ID.
899  {
900  typedef NullUInt64 Null;
901 
902  const BlockLength offset = 330;
903 
904  return ordinary(value, offset, Null());
905  }
906 
907  /// Returns instance of Events repeating group.
908  Events events() const
909  {
910  return
911  groups().
912  head<Events>();
913  }
914 
915  /// Returns instance of FeedTypes repeating group.
917  {
918  return
919  groups().
920  tail<Events>().
921  head<FeedTypes>();
922  }
923 
924  /// Returns instance of InstAttrib repeating group.
926  {
927  return
928  groups().
929  tail<Events>().
930  tail<FeedTypes>().
931  head<InstAttrib>();
932  }
933 
934  /// Returns instance of LotTypeRules repeating group.
936  {
937  return
938  groups().
939  tail<Events>().
940  tail<FeedTypes>().
941  tail<InstAttrib>().
942  head<LotTypeRules>();
943  }
944 
945  /// Size of message body in bytes.
948  {
949  if (version >= 10)
950  return 338;
951 
952  return 207;
953  }
954 
955  /// Returns class name.
957  static const Char* className()
958  {
959  return "InstrumentDefinitionFixedIncome57";
960  }
961 
962  /// FIX message type.
964  static StrRef fixType()
965  {
966  return toStrRef("d");
967  }
968 };
969 
970 /// ChannelReset.
974 {
975  /// Message template ID from SBE schema.
976  enum { TemplateId = 4 };
977 
978  /// Number of entries in Market Data message.
979  /// Entry of Entry repeating group.
982  <
984  >
985  {
986  /// Aliases base class type.
987  typedef
989  <
991  >
993 
994  /// Initializes blank instance.
996  {
997  }
998 
999  /// Initializes instance of given
1000  /// version over given memory block.
1002  const void* data,
1003  EncodedLength length,
1004  SchemaVersion version)
1005  : Base(data, length, version)
1006  {
1007  if (length < blockLength(version))
1008  throwBadBinaryData(className());
1009  }
1010 
1011  /// Market Data update action.
1013  {
1014  return UpdateTypeNew();
1015  }
1016 
1017  /// Market Data entry type.
1019  {
1020  return EntryTypeChannelReset();
1021  }
1022 
1023  /// Indicates the channel ID as defined in the XML
1024  /// configuration file.
1025  Int16 applId() const
1026  {
1027  const BlockLength offset = 0;
1028 
1029  return ordinary<Int16>(offset);
1030  }
1031 
1032  /// Returns size of entry body in bytes
1033  /// for given version of message template.
1036  {
1037  return 2;
1038  }
1039 
1040  /// Entity class name.
1042  static const Char* className()
1043  {
1044  return "ChannelReset4.Entry";
1045  }
1046  };
1047 
1048  /// Repeating group containing Entry entries.
1049  typedef
1052 
1053  /// Initializes blank instance.
1055  {
1056  }
1057 
1058  /// Initializes instance over given memory block.
1060  const void* data,
1061  EncodedLength length)
1062  : BinaryMessage(data, length)
1063  {
1064  assert(TemplateId == templateId());
1065 
1066  if (length < blockLength(version()))
1067  throwBadBinaryData(className());
1068  }
1069 
1070  /// Start of event processing time in number of nanoseconds
1071  /// since Unix epoch.
1073  {
1074  const BlockLength offset = 0;
1075 
1076  return ordinary<Timestamp>(offset);
1077  }
1078 
1079  /// Bitmap field of eight Boolean type indicators reflecting
1080  /// the end of updates for a given Globex event.
1082  {
1083  const BlockLength offset = 8;
1084 
1085  return ordinary<MatchEventIndicator>(offset);
1086  }
1087 
1088  /// Returns instance of Entries repeating group.
1090  {
1091  return
1092  groups().
1093  head<Entries>();
1094  }
1095 
1096  /// Size of message body in bytes.
1099  {
1100  return 9;
1101  }
1102 
1103  /// Returns class name.
1105  static const Char* className()
1106  {
1107  return "ChannelReset4";
1108  }
1109 
1110  /// FIX message type.
1112  static StrRef fixType()
1113  {
1114  return toStrRef("X");
1115  }
1116 };
1117 
1118 /// AdminHeartbeat.
1121 : BinaryMessage
1122 {
1123  /// Message template ID from SBE schema.
1124  enum { TemplateId = 12 };
1125 
1126  /// Initializes blank instance.
1128  {
1129  }
1130 
1131  /// Initializes instance over given memory block.
1133  const void* data,
1134  EncodedLength length)
1135  : BinaryMessage(data, length)
1136  {
1137  assert(TemplateId == templateId());
1138 
1139  if (length < blockLength(version()))
1140  throwBadBinaryData(className());
1141  }
1142 
1143  /// Size of message body in bytes.
1146  {
1147  return 0;
1148  }
1149 
1150  /// Returns class name.
1152  static const Char* className()
1153  {
1154  return "AdminHeartbeat12";
1155  }
1156 
1157  /// FIX message type.
1159  static StrRef fixType()
1160  {
1161  return toStrRef("0");
1162  }
1163 };
1164 
1165 /// AdminLogin.
1167 AdminLogin15
1168 : BinaryMessage
1169 {
1170  /// Message template ID from SBE schema.
1171  enum { TemplateId = 15 };
1172 
1173  /// Initializes blank instance.
1175  {
1176  }
1177 
1178  /// Initializes instance over given memory block.
1180  const void* data,
1181  EncodedLength length)
1182  : BinaryMessage(data, length)
1183  {
1184  assert(TemplateId == templateId());
1185 
1186  if (length < blockLength(version()))
1187  throwBadBinaryData(className());
1188  }
1189 
1190  /// Heartbeat interval (seconds).
1192  {
1193  const BlockLength offset = 0;
1194 
1195  return ordinary<Int8>(offset);
1196  }
1197 
1198  /// Size of message body in bytes.
1201  {
1202  return 1;
1203  }
1204 
1205  /// Returns class name.
1207  static const Char* className()
1208  {
1209  return "AdminLogin15";
1210  }
1211 
1212  /// FIX message type.
1214  static StrRef fixType()
1215  {
1216  return toStrRef("A");
1217  }
1218 };
1219 
1220 /// AdminLogout.
1223 : BinaryMessage
1224 {
1225  /// Message template ID from SBE schema.
1226  enum { TemplateId = 16 };
1227 
1228  /// Initializes blank instance.
1230  {
1231  }
1232 
1233  /// Initializes instance over given memory block.
1235  const void* data,
1236  EncodedLength length)
1237  : BinaryMessage(data, length)
1238  {
1239  assert(TemplateId == templateId());
1240 
1241  if (length < blockLength(version()))
1242  throwBadBinaryData(className());
1243  }
1244 
1245  /// Free format text string. May include logout confirmation
1246  /// or reason for logout.
1247  StrRef text() const
1248  {
1249  const BlockLength offset = 0;
1250  const BlockLength length = 180;
1251 
1252  return fixedStr<length>(offset);
1253  }
1254 
1255  /// Size of message body in bytes.
1258  {
1259  return 180;
1260  }
1261 
1262  /// Returns class name.
1264  static const Char* className()
1265  {
1266  return "AdminLogout16";
1267  }
1268 
1269  /// FIX message type.
1271  static StrRef fixType()
1272  {
1273  return toStrRef("5");
1274  }
1275 };
1276 
1277 /// AdminLogin.
1280 : BinaryMessage
1281 {
1282  /// Message template ID from SBE schema.
1283  enum { TemplateId = 408 };
1284 
1285  /// Initializes blank instance.
1287  {
1288  }
1289 
1290  /// Initializes instance over given memory block.
1292  const void* data,
1293  EncodedLength length)
1294  : BinaryMessage(data, length)
1295  {
1296  assert(TemplateId == templateId());
1297 
1298  if (length < blockLength(version()))
1299  throwBadBinaryData(className());
1300  }
1301 
1302  /// Heartbeat interval (seconds).
1304  {
1305  const BlockLength offset = 0;
1306 
1307  return ordinary<Int8>(offset);
1308  }
1309 
1310  /// Size of message body in bytes.
1313  {
1314  return 1;
1315  }
1316 
1317  /// Returns class name.
1319  static const Char* className()
1320  {
1321  return "AdminLogin408";
1322  }
1323 
1324  /// FIX message type.
1326  static StrRef fixType()
1327  {
1328  return toStrRef("A");
1329  }
1330 };
1331 
1332 /// AdminLogout.
1335 : BinaryMessage
1336 {
1337  /// Message template ID from SBE schema.
1338  enum { TemplateId = 409 };
1339 
1340  /// Initializes blank instance.
1342  {
1343  }
1344 
1345  /// Initializes instance over given memory block.
1347  const void* data,
1348  EncodedLength length)
1349  : BinaryMessage(data, length)
1350  {
1351  assert(TemplateId == templateId());
1352 
1353  if (length < blockLength(version()))
1354  throwBadBinaryData(className());
1355  }
1356 
1357  /// Free format text string. May include logout confirmation
1358  /// or reason for logout.
1359  StrRef text() const
1360  {
1361  const BlockLength offset = 0;
1362  const BlockLength length = 180;
1363 
1364  return fixedStr<length>(offset);
1365  }
1366 
1367  /// Size of message body in bytes.
1370  {
1371  return 180;
1372  }
1373 
1374  /// Returns class name.
1376  static const Char* className()
1377  {
1378  return "AdminLogout409";
1379  }
1380 
1381  /// FIX message type.
1383  static StrRef fixType()
1384  {
1385  return toStrRef("5");
1386  }
1387 };
1388 
1389 /// AdminHeartbeat.
1392 : BinaryMessage
1393 {
1394  /// Message template ID from SBE schema.
1395  enum { TemplateId = 410 };
1396 
1397  /// Initializes blank instance.
1399  {
1400  }
1401 
1402  /// Initializes instance over given memory block.
1404  const void* data,
1405  EncodedLength length)
1406  : BinaryMessage(data, length)
1407  {
1408  assert(TemplateId == templateId());
1409 
1410  if (length < blockLength(version()))
1411  throwBadBinaryData(className());
1412  }
1413 
1414  /// Size of message body in bytes.
1417  {
1418  return 0;
1419  }
1420 
1421  /// Returns class name.
1423  static const Char* className()
1424  {
1425  return "AdminHeartbeat410";
1426  }
1427 
1428  /// FIX message type.
1430  static StrRef fixType()
1431  {
1432  return toStrRef("0");
1433  }
1434 };
1435 
1436 /// MDInstrumentDefinitionFuture.
1439 : BinaryMessage
1440 {
1441  /// Message template ID from SBE schema.
1442  enum { TemplateId = 54 };
1443 
1444  /// Number of repeating EventType entries.
1445  /// Entry of EventsEntry repeating group.
1448  <
1450  >
1451  {
1452  /// Aliases base class type.
1453  typedef
1455  <
1457  >
1459 
1460  /// Initializes blank instance.
1462  {
1463  }
1464 
1465  /// Initializes instance of given
1466  /// version over given memory block.
1468  const void* data,
1469  EncodedLength length,
1470  SchemaVersion version)
1471  : Base(data, length, version)
1472  {
1473  if (length < blockLength(version))
1474  throwBadBinaryData(className());
1475  }
1476 
1477  /// Code to represent the type of event.
1479  {
1480  const BlockLength offset = 0;
1481 
1482  return enumeration<EventType>(offset);
1483  }
1484 
1485  /// Date and Time of instument Activation or Expiration event
1486  /// sent as number of nanoseconds since Unix epoch.
1488  {
1489  const BlockLength offset = 1;
1490 
1491  return ordinary<Timestamp>(offset);
1492  }
1493 
1494  /// Returns size of entry body in bytes
1495  /// for given version of message template.
1498  {
1499  return 9;
1500  }
1501 
1502  /// Entity class name.
1504  static const Char* className()
1505  {
1506  return "InstrumentDefinitionFuture54.EventsEntry";
1507  }
1508  };
1509 
1510  /// Repeating group containing EventsEntry entries.
1511  typedef
1514 
1515  /// Number of repeating FeedType entries.
1516  /// Entry of FeedTypesEntry repeating group.
1519  <
1521  >
1522  {
1523  /// Aliases base class type.
1524  typedef
1526  <
1528  >
1530 
1531  /// Initializes blank instance.
1533  {
1534  }
1535 
1536  /// Initializes instance of given
1537  /// version over given memory block.
1539  const void* data,
1540  EncodedLength length,
1541  SchemaVersion version)
1542  : Base(data, length, version)
1543  {
1544  if (length < blockLength(version))
1545  throwBadBinaryData(className());
1546  }
1547 
1548  /// Describes a class of service for a given data feed. GBX-
1549  /// Real Book, GBI-Implied Book.
1551  {
1552  const BlockLength offset = 0;
1553  const BlockLength length = 3;
1554 
1555  return fixedStr<length>(offset);
1556  }
1557 
1558  /// Book depth.
1560  {
1561  const BlockLength offset = 3;
1562 
1563  return ordinary<Int8>(offset);
1564  }
1565 
1566  /// Returns size of entry body in bytes
1567  /// for given version of message template.
1570  {
1571  return 4;
1572  }
1573 
1574  /// Entity class name.
1576  static const Char* className()
1577  {
1578  return "InstrumentDefinitionFuture54.FeedTypesEntry";
1579  }
1580  };
1581 
1582  /// Repeating group containing FeedTypesEntry entries.
1583  typedef
1586 
1587  /// Number of repeating InstrAttribType entries.
1588  /// Entry of InstAttribEntry repeating group.
1591  <
1593  >
1594  {
1595  /// Aliases base class type.
1596  typedef
1598  <
1600  >
1602 
1603  /// Initializes blank instance.
1605  {
1606  }
1607 
1608  /// Initializes instance of given
1609  /// version over given memory block.
1611  const void* data,
1612  EncodedLength length,
1613  SchemaVersion version)
1614  : Base(data, length, version)
1615  {
1616  if (length < blockLength(version))
1617  throwBadBinaryData(className());
1618  }
1619 
1620  /// Instrument eligibility attributes.
1622  {
1623  return InstAttribType();
1624  }
1625 
1626  /// Bitmap field of 32 Boolean type instrument eligibility
1627  /// flags.
1629  {
1630  const BlockLength offset = 0;
1631 
1632  return ordinary<InstAttribValue>(offset);
1633  }
1634 
1635  /// Returns size of entry body in bytes
1636  /// for given version of message template.
1639  {
1640  return 4;
1641  }
1642 
1643  /// Entity class name.
1645  static const Char* className()
1646  {
1647  return "InstrumentDefinitionFuture54.InstAttribEntry";
1648  }
1649  };
1650 
1651  /// Repeating group containing InstAttribEntry entries.
1652  typedef
1655 
1656  /// Number of entries.
1657  /// Entry of LotTypeRulesEntry repeating group.
1660  <
1662  >
1663  {
1664  /// Aliases base class type.
1665  typedef
1667  <
1669  >
1671 
1672  /// Initializes blank instance.
1674  {
1675  }
1676 
1677  /// Initializes instance of given
1678  /// version over given memory block.
1680  const void* data,
1681  EncodedLength length,
1682  SchemaVersion version)
1683  : Base(data, length, version)
1684  {
1685  if (length < blockLength(version))
1686  throwBadBinaryData(className());
1687  }
1688 
1689  /// This tag is required to interpret the value in tag
1690  /// 1231-MinLotSize.
1691  Int8 lotType() const
1692  {
1693  const BlockLength offset = 0;
1694 
1695  return ordinary<Int8>(offset);
1696  }
1697 
1698  /// Minimum quantity accepted for order entry. If tag
1699  /// 1093-LotType=4, this value is the minimum quantity for
1700  /// order entry expressed in the applicable units, specified
1701  /// in tag 996-UnitOfMeasure, e.g. megawatts.
1702  bool minLotSize(Decimal& value) const
1703  {
1704  typedef NullDecimalQty Null;
1705 
1706  const BlockLength offset = 1;
1707 
1708  return decimal(value, offset, Null());
1709  }
1710 
1711  /// Returns size of entry body in bytes
1712  /// for given version of message template.
1715  {
1716  return 5;
1717  }
1718 
1719  /// Entity class name.
1721  static const Char* className()
1722  {
1723  return "InstrumentDefinitionFuture54.LotTypeRulesEntry";
1724  }
1725  };
1726 
1727  /// Repeating group containing LotTypeRulesEntry entries.
1728  typedef
1731 
1732  /// Initializes blank instance.
1734  {
1735  }
1736 
1737  /// Initializes instance over given memory block.
1739  const void* data,
1740  EncodedLength length)
1741  : BinaryMessage(data, length)
1742  {
1743  assert(TemplateId == templateId());
1744 
1745  if (length < blockLength(version()))
1746  throwBadBinaryData(className());
1747  }
1748 
1749  /// Bitmap field of eight Boolean type indicators reflecting
1750  /// the end of updates for a given Globex event.
1752  {
1753  const BlockLength offset = 0;
1754 
1755  return ordinary<MatchEventIndicator>(offset);
1756  }
1757 
1758  /// Total number of instruments in the Replay loop. Used on
1759  /// Replay Feed only.
1761  {
1762  typedef NullUInt32 Null;
1763 
1764  const BlockLength offset = 1;
1765 
1766  return ordinary(value, offset, Null());
1767  }
1768 
1769  /// Last Security update action on Incremental feed, 'D' or
1770  /// 'M' is used when a mid-week deletion or modification (i.e.
1771  /// extension) occurs.
1774  {
1775  const BlockLength offset = 5;
1776 
1777  return enumeration<SecurityUpdateAction>(offset);
1778  }
1779 
1780  /// Timestamp of when the instrument was last added, modified
1781  /// or deleted.
1783  {
1784  const BlockLength offset = 6;
1785 
1786  return ordinary<Timestamp>(offset);
1787  }
1788 
1789  /// Identifies the current state of the instrument. In
1790  /// Security Definition message this tag is available in the
1791  /// Instrument Replay feed only.
1792  bool
1795  {
1796  typedef NullUInt8 Null;
1797 
1798  const BlockLength offset = 14;
1799 
1800  return enumeration<SecurityTradingStatus>(value, offset, Null());
1801  }
1802 
1803  /// The channel ID as defined in the XML Configuration file.
1804  Int16 applId() const
1805  {
1806  const BlockLength offset = 15;
1807 
1808  return ordinary<Int16>(offset);
1809  }
1810 
1811  /// Identifies the market segment, populated for all CME
1812  /// Globex instruments.
1814  {
1815  const BlockLength offset = 17;
1816 
1817  return ordinary<UInt8>(offset);
1818  }
1819 
1820  /// Product complex.
1822  {
1823  const BlockLength offset = 18;
1824 
1825  return ordinary<UInt8>(offset);
1826  }
1827 
1828  /// Exchange used to identify a security.
1830  {
1831  const BlockLength offset = 19;
1832  const BlockLength length = 4;
1833 
1834  return fixedStr<length>(offset);
1835  }
1836 
1837  /// Security Group Code.
1839  {
1840  const BlockLength offset = 23;
1841  const BlockLength length = 6;
1842 
1843  return fixedStr<length>(offset);
1844  }
1845 
1846  /// The underlying asset code also known as Product Code.
1847  StrRef asset() const
1848  {
1849  const BlockLength offset = 29;
1850  const BlockLength length = 6;
1851 
1852  return fixedStr<length>(offset);
1853  }
1854 
1855  /// Instrument Name or Symbol.
1856  StrRef symbol() const
1857  {
1858  const BlockLength offset = 35;
1859  const BlockLength length = 20;
1860 
1861  return fixedStr<length>(offset);
1862  }
1863 
1864  /// Unique instrument ID.
1866  {
1867  const BlockLength offset = 55;
1868 
1869  return ordinary<Int32>(offset);
1870  }
1871 
1872  /// Identifies class or source of tag 48-SecurityID value.
1874  {
1875  return SecurityIDSource();
1876  }
1877 
1878  /// Security Type.
1880  {
1881  const BlockLength offset = 59;
1882  const BlockLength length = 6;
1883 
1884  return fixedStr<length>(offset);
1885  }
1886 
1887  /// ISO standard instrument categorization code.
1888  StrRef cfiCode() const
1889  {
1890  const BlockLength offset = 65;
1891  const BlockLength length = 6;
1892 
1893  return fixedStr<length>(offset);
1894  }
1895 
1896  /// This field provides the actual calendar date for contract
1897  /// maturity.
1899  {
1900  typedef NullMaturityMonthYear Null;
1901 
1902  const BlockLength offset = 71;
1903 
1904  return ordinary(value, offset, Null());
1905  }
1906 
1907  /// Identifies currency used for price.
1909  {
1910  const BlockLength offset = 76;
1911  const BlockLength length = 3;
1912 
1913  return fixedStr<length>(offset);
1914  }
1915 
1916  /// Identifies currency used for settlement, if different from
1917  /// trading currency.
1919  {
1920  const BlockLength offset = 79;
1921  const BlockLength length = 3;
1922 
1923  return fixedStr<length>(offset);
1924  }
1925 
1926  /// Matching algorithm.
1928  {
1929  const BlockLength offset = 82;
1930 
1931  return ordinary<CHAR>(offset);
1932  }
1933 
1934  /// The minimum trading volume for a security.
1936  {
1937  const BlockLength offset = 83;
1938 
1939  return ordinary<UInt32>(offset);
1940  }
1941 
1942  /// The maximum trading volume for a security.
1944  {
1945  const BlockLength offset = 87;
1946 
1947  return ordinary<UInt32>(offset);
1948  }
1949 
1950  /// Minimum constant tick for the instrument, sent only if
1951  /// instrument is non-VTT (Variable Tick table) eligible.
1953  {
1954  const BlockLength offset = 91;
1955 
1956  return decimal<PRICE9>(offset);
1957  }
1958 
1959  /// Contains the multiplier to convert the CME Globex display
1960  /// price to the conventional price.
1962  {
1963  const BlockLength offset = 99;
1964 
1965  return decimal<Decimal9>(offset);
1966  }
1967 
1968  /// Price Denominator of Main Fraction.
1969  bool mainFraction(UInt8& value) const
1970  {
1971  typedef NullUInt8 Null;
1972 
1973  const BlockLength offset = 107;
1974 
1975  return ordinary(value, offset, Null());
1976  }
1977 
1978  /// Price Denominator of Sub Fraction.
1979  bool subFraction(UInt8& value) const
1980  {
1981  typedef NullUInt8 Null;
1982 
1983  const BlockLength offset = 108;
1984 
1985  return ordinary(value, offset, Null());
1986  }
1987 
1988  /// Number of decimals in fractional display price.
1990  {
1991  typedef NullUInt8 Null;
1992 
1993  const BlockLength offset = 109;
1994 
1995  return ordinary(value, offset, Null());
1996  }
1997 
1998  /// Unit of measure for the products' original contract size.
1999  /// This will be populated for all products listed on CME
2000  /// Globex.
2002  {
2003  const BlockLength offset = 110;
2004  const BlockLength length = 30;
2005 
2006  return fixedStr<length>(offset);
2007  }
2008 
2009  /// This field contains the contract size for each instrument.
2010  /// Used in combination with tag 996-UnitofMeasure.
2012  {
2013  typedef NullDecimal9 Null;
2014 
2015  const BlockLength offset = 140;
2016 
2017  return decimal(value, offset, Null());
2018  }
2019 
2020  /// Reference price for prelisted instruments or the last
2021  /// calculated Settlement whether it be Theoretical,
2022  /// Preliminary or a Final Settle of the session.
2024  {
2025  typedef NullPRICE9 Null;
2026 
2027  const BlockLength offset = 148;
2028 
2029  return decimal(value, offset, Null());
2030  }
2031 
2032  /// Bitmap field of eight Boolean type indicators representing
2033  /// settlement price type.
2035  {
2036  const BlockLength offset = 156;
2037 
2038  return ordinary<SettlPriceType>(offset);
2039  }
2040 
2041  /// The total open interest for the market at the close of the
2042  /// prior trading session.
2044  {
2045  typedef NullInt32 Null;
2046 
2047  const BlockLength offset = 157;
2048 
2049  return ordinary(value, offset, Null());
2050  }
2051 
2052  /// The total cleared volume of instrument traded during the
2053  /// prior trading session.
2055  {
2056  typedef NullInt32 Null;
2057 
2058  const BlockLength offset = 161;
2059 
2060  return ordinary(value, offset, Null());
2061  }
2062 
2063  /// Allowable high limit price for the trading day.
2065  {
2066  typedef NullPRICE9 Null;
2067 
2068  const BlockLength offset = 165;
2069 
2070  return decimal(value, offset, Null());
2071  }
2072 
2073  /// Allowable low limit price for the trading day.
2075  {
2076  typedef NullPRICE9 Null;
2077 
2078  const BlockLength offset = 173;
2079 
2080  return decimal(value, offset, Null());
2081  }
2082 
2083  /// Differential value for price banding.
2085  {
2086  typedef NullPRICE9 Null;
2087 
2088  const BlockLength offset = 181;
2089 
2090  return decimal(value, offset, Null());
2091  }
2092 
2093  /// Indicates the quantity that a contract will decay daily by
2094  /// once the decay start date is reached.
2096  {
2097  typedef NullInt32 Null;
2098 
2099  const BlockLength offset = 189;
2100 
2101  return ordinary(value, offset, Null());
2102  }
2103 
2104  /// Indicates the date at which a decaying contract will begin
2105  /// to decay.
2107  {
2108  typedef NullLocalMktDate Null;
2109  typedef LocalMktDate FieldValue;
2110 
2111  const BlockLength offset = 193;
2112 
2113  FieldValue fieldValue;
2114 
2115  if (ordinary(fieldValue, offset, Null()))
2116  {
2117  value = localMktDateToTimestamp(fieldValue);
2118  return true;
2119  }
2120  return false;
2121  }
2122 
2123  /// Fixed contract value assigned to each product.
2125  {
2126  typedef NullInt32 Null;
2127 
2128  const BlockLength offset = 195;
2129 
2130  return ordinary(value, offset, Null());
2131  }
2132 
2133  /// Number of deliverable units per instrument, e.g., peak
2134  /// days in maturity month or number of calendar days in
2135  /// maturity month.
2137  {
2138  typedef NullInt32 Null;
2139 
2140  const BlockLength offset = 199;
2141 
2142  return ordinary(value, offset, Null());
2143  }
2144 
2145  /// Indicates the type of multiplier being applied to the
2146  /// product. Optionally used in combination with tag
2147  /// 231-ContractMultiplier.
2149  {
2150  typedef NullInt8 Null;
2151 
2152  const BlockLength offset = 203;
2153 
2154  return ordinary(value, offset, Null());
2155  }
2156 
2157  /// The schedule according to which the electricity is
2158  /// delivered in a physical contract, or priced in a financial
2159  /// contract. Specifies whether the contract is defined
2160  /// according to the Easter Peak, Eastern Off-Peak, Western
2161  /// Peak or Western Off-Peak.
2163  {
2164  typedef NullInt8 Null;
2165 
2166  const BlockLength offset = 204;
2167 
2168  return ordinary(value, offset, Null());
2169  }
2170 
2171  /// Monetary value equivalent to the minimum price fluctuation.
2173  {
2174  typedef NullPRICE9 Null;
2175 
2176  const BlockLength offset = 205;
2177 
2178  return decimal(value, offset, Null());
2179  }
2180 
2181  /// User-defined instruments flag.
2183  {
2184  const BlockLength offset = 213;
2185 
2186  return ordinary<UserDefinedInstrument>(offset);
2187  }
2188 
2189  /// Indicates session date corresponding to the settlement
2190  /// price in tag 1150-TradingReferencePrice.
2192  {
2193  typedef NullLocalMktDate Null;
2194  typedef LocalMktDate FieldValue;
2195 
2196  const BlockLength offset = 214;
2197 
2198  FieldValue fieldValue;
2199 
2200  if (ordinary(fieldValue, offset, Null()))
2201  {
2202  value = localMktDateToTimestamp(fieldValue);
2203  return true;
2204  }
2205  return false;
2206  }
2207 
2208  /// External unique instrument ID.
2210  {
2211  typedef NullUInt64 Null;
2212 
2213  const BlockLength offset = 216;
2214  const SchemaVersion since = 10;
2215 
2216  return ordinary(value, offset, Null(), since);
2217  }
2218 
2219  /// Returns instance of Events repeating group.
2220  Events events() const
2221  {
2222  return
2223  groups().
2224  head<Events>();
2225  }
2226 
2227  /// Returns instance of FeedTypes repeating group.
2229  {
2230  return
2231  groups().
2232  tail<Events>().
2233  head<FeedTypes>();
2234  }
2235 
2236  /// Returns instance of InstAttrib repeating group.
2238  {
2239  return
2240  groups().
2241  tail<Events>().
2242  tail<FeedTypes>().
2243  head<InstAttrib>();
2244  }
2245 
2246  /// Returns instance of LotTypeRules repeating group.
2248  {
2249  return
2250  groups().
2251  tail<Events>().
2252  tail<FeedTypes>().
2253  tail<InstAttrib>().
2254  head<LotTypeRules>();
2255  }
2256 
2257  /// Size of message body in bytes.
2260  {
2261  if (version >= 10)
2262  return 224;
2263 
2264  return 216;
2265  }
2266 
2267  /// Returns class name.
2269  static const Char* className()
2270  {
2271  return "InstrumentDefinitionFuture54";
2272  }
2273 
2274  /// FIX message type.
2276  static StrRef fixType()
2277  {
2278  return toStrRef("d");
2279  }
2280 };
2281 
2282 /// MDInstrumentDefinitionSpread.
2285 : BinaryMessage
2286 {
2287  /// Message template ID from SBE schema.
2288  enum { TemplateId = 56 };
2289 
2290  /// Number of repeating EventType entries.
2291  /// Entry of EventsEntry repeating group.
2294  <
2296  >
2297  {
2298  /// Aliases base class type.
2299  typedef
2301  <
2303  >
2305 
2306  /// Initializes blank instance.
2308  {
2309  }
2310 
2311  /// Initializes instance of given
2312  /// version over given memory block.
2314  const void* data,
2315  EncodedLength length,
2316  SchemaVersion version)
2317  : Base(data, length, version)
2318  {
2319  if (length < blockLength(version))
2320  throwBadBinaryData(className());
2321  }
2322 
2323  /// Code to represent the type of event.
2325  {
2326  const BlockLength offset = 0;
2327 
2328  return enumeration<EventType>(offset);
2329  }
2330 
2331  /// Date and time of instument Activation or Expiration event
2332  /// sent as number of nanoseconds since Unix epoch.
2334  {
2335  const BlockLength offset = 1;
2336 
2337  return ordinary<Timestamp>(offset);
2338  }
2339 
2340  /// Returns size of entry body in bytes
2341  /// for given version of message template.
2344  {
2345  return 9;
2346  }
2347 
2348  /// Entity class name.
2350  static const Char* className()
2351  {
2352  return "InstrumentDefinitionSpread56.EventsEntry";
2353  }
2354  };
2355 
2356  /// Repeating group containing EventsEntry entries.
2357  typedef
2360 
2361  /// Number of FeedType entries.
2362  /// Entry of FeedTypesEntry repeating group.
2365  <
2367  >
2368  {
2369  /// Aliases base class type.
2370  typedef
2372  <
2374  >
2376 
2377  /// Initializes blank instance.
2379  {
2380  }
2381 
2382  /// Initializes instance of given
2383  /// version over given memory block.
2385  const void* data,
2386  EncodedLength length,
2387  SchemaVersion version)
2388  : Base(data, length, version)
2389  {
2390  if (length < blockLength(version))
2391  throwBadBinaryData(className());
2392  }
2393 
2394  /// Describes a class of service for a given data feed. GBX-
2395  /// Real Book, GBI-Implied Book.
2397  {
2398  const BlockLength offset = 0;
2399  const BlockLength length = 3;
2400 
2401  return fixedStr<length>(offset);
2402  }
2403 
2404  /// Identifies the depth of book.
2406  {
2407  const BlockLength offset = 3;
2408 
2409  return ordinary<Int8>(offset);
2410  }
2411 
2412  /// Returns size of entry body in bytes
2413  /// for given version of message template.
2416  {
2417  return 4;
2418  }
2419 
2420  /// Entity class name.
2422  static const Char* className()
2423  {
2424  return "InstrumentDefinitionSpread56.FeedTypesEntry";
2425  }
2426  };
2427 
2428  /// Repeating group containing FeedTypesEntry entries.
2429  typedef
2432 
2433  /// Number of InstrAttribType entries.
2434  /// Entry of InstAttribEntry repeating group.
2437  <
2439  >
2440  {
2441  /// Aliases base class type.
2442  typedef
2444  <
2446  >
2448 
2449  /// Initializes blank instance.
2451  {
2452  }
2453 
2454  /// Initializes instance of given
2455  /// version over given memory block.
2457  const void* data,
2458  EncodedLength length,
2459  SchemaVersion version)
2460  : Base(data, length, version)
2461  {
2462  if (length < blockLength(version))
2463  throwBadBinaryData(className());
2464  }
2465 
2466  /// Instrument Eligibility Attributes.
2468  {
2469  return InstAttribType();
2470  }
2471 
2472  /// Bitmap field of 32 Boolean type Instrument eligibility
2473  /// flags.
2475  {
2476  const BlockLength offset = 0;
2477 
2478  return ordinary<InstAttribValue>(offset);
2479  }
2480 
2481  /// Returns size of entry body in bytes
2482  /// for given version of message template.
2485  {
2486  return 4;
2487  }
2488 
2489  /// Entity class name.
2491  static const Char* className()
2492  {
2493  return "InstrumentDefinitionSpread56.InstAttribEntry";
2494  }
2495  };
2496 
2497  /// Repeating group containing InstAttribEntry entries.
2498  typedef
2501 
2502  /// Number of entries.
2503  /// Entry of LotTypeRulesEntry repeating group.
2506  <
2508  >
2509  {
2510  /// Aliases base class type.
2511  typedef
2513  <
2515  >
2517 
2518  /// Initializes blank instance.
2520  {
2521  }
2522 
2523  /// Initializes instance of given
2524  /// version over given memory block.
2526  const void* data,
2527  EncodedLength length,
2528  SchemaVersion version)
2529  : Base(data, length, version)
2530  {
2531  if (length < blockLength(version))
2532  throwBadBinaryData(className());
2533  }
2534 
2535  /// This tag is required to interpret the value in tag
2536  /// 1231-MinLotSize.
2537  Int8 lotType() const
2538  {
2539  const BlockLength offset = 0;
2540 
2541  return ordinary<Int8>(offset);
2542  }
2543 
2544  /// Minimum quantity accepted for order entry. If tag
2545  /// 1093-LotType=4, this value is the minimum quantity for
2546  /// order entry expressed in the applicable units, specified
2547  /// in tag 996-UnitOfMeasure, e.g. megawatts.
2548  bool minLotSize(Decimal& value) const
2549  {
2550  typedef NullDecimalQty Null;
2551 
2552  const BlockLength offset = 1;
2553 
2554  return decimal(value, offset, Null());
2555  }
2556 
2557  /// Returns size of entry body in bytes
2558  /// for given version of message template.
2561  {
2562  return 5;
2563  }
2564 
2565  /// Entity class name.
2567  static const Char* className()
2568  {
2569  return "InstrumentDefinitionSpread56.LotTypeRulesEntry";
2570  }
2571  };
2572 
2573  /// Repeating group containing LotTypeRulesEntry entries.
2574  typedef
2577 
2578  /// Number of Leg entries.
2579  /// Entry of LegsEntry repeating group.
2582  <
2584  >
2585  {
2586  /// Aliases base class type.
2587  typedef
2589  <
2591  >
2593 
2594  /// Initializes blank instance.
2596  {
2597  }
2598 
2599  /// Initializes instance of given
2600  /// version over given memory block.
2602  const void* data,
2603  EncodedLength length,
2604  SchemaVersion version)
2605  : Base(data, length, version)
2606  {
2607  if (length < blockLength(version))
2608  throwBadBinaryData(className());
2609  }
2610 
2611  /// Leg Security ID.
2613  {
2614  const BlockLength offset = 0;
2615 
2616  return ordinary<Int32>(offset);
2617  }
2618 
2619  /// Identifies source of tag 602-LegSecurityID value.
2621  {
2622  return SecurityIDSource();
2623  }
2624 
2625  /// Leg side.
2627  {
2628  const BlockLength offset = 4;
2629 
2630  return enumeration<LegSide>(offset);
2631  }
2632 
2633  /// Leg ratio of quantity for this individual leg relative to
2634  /// the entire multi-leg instrument.
2636  {
2637  const BlockLength offset = 5;
2638 
2639  return ordinary<Int8>(offset);
2640  }
2641 
2642  /// Price for the future leg of a UDS Covered instrument.
2643  bool legPrice(Decimal& value) const
2644  {
2645  typedef NullPRICE9 Null;
2646 
2647  const BlockLength offset = 6;
2648 
2649  return decimal(value, offset, Null());
2650  }
2651 
2652  /// Delta used to calculate the quantity of futures used to
2653  /// cover the option or option strategy.
2655  {
2656  typedef NullDecimalQty Null;
2657 
2658  const BlockLength offset = 14;
2659 
2660  return decimal(value, offset, Null());
2661  }
2662 
2663  /// Returns size of entry body in bytes
2664  /// for given version of message template.
2667  {
2668  return 18;
2669  }
2670 
2671  /// Entity class name.
2673  static const Char* className()
2674  {
2675  return "InstrumentDefinitionSpread56.LegsEntry";
2676  }
2677  };
2678 
2679  /// Repeating group containing LegsEntry entries.
2680  typedef
2683 
2684  /// Initializes blank instance.
2686  {
2687  }
2688 
2689  /// Initializes instance over given memory block.
2691  const void* data,
2692  EncodedLength length)
2693  : BinaryMessage(data, length)
2694  {
2695  assert(TemplateId == templateId());
2696 
2697  if (length < blockLength(version()))
2698  throwBadBinaryData(className());
2699  }
2700 
2701  /// Bitmap field of eight Boolean type indicators reflecting
2702  /// the end of updates for a given Globex event.
2704  {
2705  const BlockLength offset = 0;
2706 
2707  return ordinary<MatchEventIndicator>(offset);
2708  }
2709 
2710  /// Total number of instruments in the Replay loop. Used on
2711  /// Replay Feed only.
2713  {
2714  typedef NullUInt32 Null;
2715 
2716  const BlockLength offset = 1;
2717 
2718  return ordinary(value, offset, Null());
2719  }
2720 
2721  /// Last Security update action on Incremental feed, 'D' or
2722  /// 'M' is used when a mid-week deletion or modification (i.e.
2723  /// extension) occurs.
2726  {
2727  const BlockLength offset = 5;
2728 
2729  return enumeration<SecurityUpdateAction>(offset);
2730  }
2731 
2732  /// Timestamp of when the instrument was last added, modified
2733  /// or deleted.
2735  {
2736  const BlockLength offset = 6;
2737 
2738  return ordinary<Timestamp>(offset);
2739  }
2740 
2741  /// Identifies the current state of the instrument. The data
2742  /// is available in the Instrument Replay feed only.
2743  bool
2746  {
2747  typedef NullUInt8 Null;
2748 
2749  const BlockLength offset = 14;
2750 
2751  return enumeration<SecurityTradingStatus>(value, offset, Null());
2752  }
2753 
2754  /// The channel ID as defined in the XML Configuration file.
2755  Int16 applId() const
2756  {
2757  const BlockLength offset = 15;
2758 
2759  return ordinary<Int16>(offset);
2760  }
2761 
2762  /// Identifies the market segment, populated for all CME
2763  /// Globex instruments.
2765  {
2766  const BlockLength offset = 17;
2767 
2768  return ordinary<UInt8>(offset);
2769  }
2770 
2771  /// Product complex.
2773  {
2774  typedef NullUInt8 Null;
2775 
2776  const BlockLength offset = 18;
2777 
2778  return ordinary(value, offset, Null());
2779  }
2780 
2781  /// Exchange used to identify a security.
2783  {
2784  const BlockLength offset = 19;
2785  const BlockLength length = 4;
2786 
2787  return fixedStr<length>(offset);
2788  }
2789 
2790  /// Security Group Code.
2792  {
2793  const BlockLength offset = 23;
2794  const BlockLength length = 6;
2795 
2796  return fixedStr<length>(offset);
2797  }
2798 
2799  /// The underlying asset code also known as Product Code.
2800  StrRef asset() const
2801  {
2802  const BlockLength offset = 29;
2803  const BlockLength length = 6;
2804 
2805  return fixedStr<length>(offset);
2806  }
2807 
2808  /// Instrument Name or Symbol. Previously used as Group Code.
2809  StrRef symbol() const
2810  {
2811  const BlockLength offset = 35;
2812  const BlockLength length = 20;
2813 
2814  return fixedStr<length>(offset);
2815  }
2816 
2817  /// Unique instrument ID.
2819  {
2820  const BlockLength offset = 55;
2821 
2822  return ordinary<Int32>(offset);
2823  }
2824 
2825  /// Identifies class or source of the security ID (Tag 48)
2826  /// value.
2828  {
2829  return SecurityIDSource();
2830  }
2831 
2832  /// Security Type.
2834  {
2835  const BlockLength offset = 59;
2836  const BlockLength length = 6;
2837 
2838  return fixedStr<length>(offset);
2839  }
2840 
2841  /// ISO standard instrument categorization code.
2842  StrRef cfiCode() const
2843  {
2844  const BlockLength offset = 65;
2845  const BlockLength length = 6;
2846 
2847  return fixedStr<length>(offset);
2848  }
2849 
2850  /// This field provides the actual calendar date for contract
2851  /// maturity.
2853  {
2854  typedef NullMaturityMonthYear Null;
2855 
2856  const BlockLength offset = 71;
2857 
2858  return ordinary(value, offset, Null());
2859  }
2860 
2861  /// Identifies currency used for price.
2863  {
2864  const BlockLength offset = 76;
2865  const BlockLength length = 3;
2866 
2867  return fixedStr<length>(offset);
2868  }
2869 
2870  /// Strategy type.
2872  {
2873  const BlockLength offset = 79;
2874  const BlockLength length = 5;
2875 
2876  return fixedStr<length>(offset);
2877  }
2878 
2879  /// User-defined instruments flag.
2881  {
2882  const BlockLength offset = 84;
2883 
2884  return ordinary<UserDefinedInstrument>(offset);
2885  }
2886 
2887  /// Matching algorithm.
2889  {
2890  const BlockLength offset = 85;
2891 
2892  return ordinary<CHAR>(offset);
2893  }
2894 
2895  /// The minimum trading volume for a security.
2897  {
2898  const BlockLength offset = 86;
2899 
2900  return ordinary<UInt32>(offset);
2901  }
2902 
2903  /// The maximum trading volume for a security.
2905  {
2906  const BlockLength offset = 90;
2907 
2908  return ordinary<UInt32>(offset);
2909  }
2910 
2911  /// Minimum constant tick for the instrument, sent only if
2912  /// instrument is non-VTT (Variable Tick table) eligible.
2914  {
2915  typedef NullPRICE9 Null;
2916 
2917  const BlockLength offset = 94;
2918 
2919  return decimal(value, offset, Null());
2920  }
2921 
2922  /// Contains the multiplier to convert the CME Globex display
2923  /// price to the conventional price.
2925  {
2926  const BlockLength offset = 102;
2927 
2928  return decimal<Decimal9>(offset);
2929  }
2930 
2931  /// Number of decimals in fractional display price.
2933  {
2934  typedef NullUInt8 Null;
2935 
2936  const BlockLength offset = 110;
2937 
2938  return ordinary(value, offset, Null());
2939  }
2940 
2941  /// Used for price calculation in spread and leg pricing.
2942  bool priceRatio(Decimal& value) const
2943  {
2944  typedef NullPRICE9 Null;
2945 
2946  const BlockLength offset = 111;
2947 
2948  return decimal(value, offset, Null());
2949  }
2950 
2951  /// Tick Rule.
2952  bool tickRule(Int8& value) const
2953  {
2954  typedef NullInt8 Null;
2955 
2956  const BlockLength offset = 119;
2957 
2958  return ordinary(value, offset, Null());
2959  }
2960 
2961  /// Unit of measure for the products' original contract size.
2963  {
2964  const BlockLength offset = 120;
2965  const BlockLength length = 30;
2966 
2967  return fixedStr<length>(offset);
2968  }
2969 
2970  /// Reference price - the most recently available Settlement
2971  /// whether it be Theoretical, Preliminary or a Final Settle
2972  /// of the session.
2974  {
2975  typedef NullPRICE9 Null;
2976 
2977  const BlockLength offset = 150;
2978 
2979  return decimal(value, offset, Null());
2980  }
2981 
2982  /// Bitmap field of eight Boolean type indicators representing
2983  /// settlement price type.
2985  {
2986  const BlockLength offset = 158;
2987 
2988  return ordinary<SettlPriceType>(offset);
2989  }
2990 
2991  /// The total open interest for the market at the close of the
2992  /// prior trading session.
2994  {
2995  typedef NullInt32 Null;
2996 
2997  const BlockLength offset = 159;
2998 
2999  return ordinary(value, offset, Null());
3000  }
3001 
3002  /// The total cleared volume of instrument traded during the
3003  /// prior trading session.
3005  {
3006  typedef NullInt32 Null;
3007 
3008  const BlockLength offset = 163;
3009 
3010  return ordinary(value, offset, Null());
3011  }
3012 
3013  /// Allowable high limit price for the trading day.
3015  {
3016  typedef NullPRICE9 Null;
3017 
3018  const BlockLength offset = 167;
3019 
3020  return decimal(value, offset, Null());
3021  }
3022 
3023  /// Allowable low limit price for the trading day.
3025  {
3026  typedef NullPRICE9 Null;
3027 
3028  const BlockLength offset = 175;
3029 
3030  return decimal(value, offset, Null());
3031  }
3032 
3033  /// Differential value for price banding.
3035  {
3036  typedef NullPRICE9 Null;
3037 
3038  const BlockLength offset = 183;
3039 
3040  return decimal(value, offset, Null());
3041  }
3042 
3043  /// Price Denominator of Main Fraction.
3044  bool mainFraction(UInt8& value) const
3045  {
3046  typedef NullUInt8 Null;
3047 
3048  const BlockLength offset = 191;
3049 
3050  return ordinary(value, offset, Null());
3051  }
3052 
3053  /// Price Denominator of Sub Fraction.
3054  bool subFraction(UInt8& value) const
3055  {
3056  typedef NullUInt8 Null;
3057 
3058  const BlockLength offset = 192;
3059 
3060  return ordinary(value, offset, Null());
3061  }
3062 
3063  /// Indicates session date corresponding to the settlement
3064  /// price in tag 1150-TradingReferencePrice.
3066  {
3067  typedef NullLocalMktDate Null;
3068  typedef LocalMktDate FieldValue;
3069 
3070  const BlockLength offset = 193;
3071 
3072  FieldValue fieldValue;
3073 
3074  if (ordinary(fieldValue, offset, Null()))
3075  {
3076  value = localMktDateToTimestamp(fieldValue);
3077  return true;
3078  }
3079  return false;
3080  }
3081 
3082  /// Price quotation method.
3084  {
3085  const BlockLength offset = 195;
3086  const BlockLength length = 5;
3087  const SchemaVersion since = 10;
3088 
3089  return fixedStr<length>(offset, since);
3090  }
3091 
3092  /// Risk Set identifies the list of instruments sharing credit
3093  /// limits set up.
3094  StrRef riskSet() const
3095  {
3096  const BlockLength offset = 200;
3097  const BlockLength length = 6;
3098  const SchemaVersion since = 10;
3099 
3100  return fixedStr<length>(offset, since);
3101  }
3102 
3103  /// Market Set defines the bilateral relationship and Self
3104  /// Match Prevention configuration for eligible markets.
3106  {
3107  const BlockLength offset = 206;
3108  const BlockLength length = 6;
3109  const SchemaVersion since = 10;
3110 
3111  return fixedStr<length>(offset, since);
3112  }
3113 
3114  /// External unique instrument ID.
3116  {
3117  typedef NullUInt64 Null;
3118 
3119  const BlockLength offset = 212;
3120  const SchemaVersion since = 10;
3121 
3122  return ordinary(value, offset, Null(), since);
3123  }
3124 
3125  /// Long name of the instrument.
3127  {
3128  const BlockLength offset = 220;
3129  const BlockLength length = 35;
3130  const SchemaVersion since = 10;
3131 
3132  return fixedStr<length>(offset, since);
3133  }
3134 
3135  /// Returns instance of Events repeating group.
3136  Events events() const
3137  {
3138  return
3139  groups().
3140  head<Events>();
3141  }
3142 
3143  /// Returns instance of FeedTypes repeating group.
3145  {
3146  return
3147  groups().
3148  tail<Events>().
3149  head<FeedTypes>();
3150  }
3151 
3152  /// Returns instance of InstAttrib repeating group.
3154  {
3155  return
3156  groups().
3157  tail<Events>().
3158  tail<FeedTypes>().
3159  head<InstAttrib>();
3160  }
3161 
3162  /// Returns instance of LotTypeRules repeating group.
3164  {
3165  return
3166  groups().
3167  tail<Events>().
3168  tail<FeedTypes>().
3169  tail<InstAttrib>().
3170  head<LotTypeRules>();
3171  }
3172 
3173  /// Returns instance of Legs repeating group.
3174  Legs legs() const
3175  {
3176  return
3177  groups().
3178  tail<Events>().
3179  tail<FeedTypes>().
3180  tail<InstAttrib>().
3181  tail<LotTypeRules>().
3182  head<Legs>();
3183  }
3184 
3185  /// Size of message body in bytes.
3188  {
3189  if (version >= 10)
3190  return 255;
3191 
3192  return 195;
3193  }
3194 
3195  /// Returns class name.
3197  static const Char* className()
3198  {
3199  return "InstrumentDefinitionSpread56";
3200  }
3201 
3202  /// FIX message type.
3204  static StrRef fixType()
3205  {
3206  return toStrRef("d");
3207  }
3208 };
3209 
3210 /// SecurityStatus.
3213 : BinaryMessage
3214 {
3215  /// Message template ID from SBE schema.
3216  enum { TemplateId = 30 };
3217 
3218  /// Initializes blank instance.
3220  {
3221  }
3222 
3223  /// Initializes instance over given memory block.
3225  const void* data,
3226  EncodedLength length)
3227  : BinaryMessage(data, length)
3228  {
3229  assert(TemplateId == templateId());
3230 
3231  if (length < blockLength(version()))
3232  throwBadBinaryData(className());
3233  }
3234 
3235  /// Start of event processing time in number of nanoseconds
3236  /// since Unix epoch.
3238  {
3239  const BlockLength offset = 0;
3240 
3241  return ordinary<Timestamp>(offset);
3242  }
3243 
3244  /// Security Group.
3246  {
3247  const BlockLength offset = 8;
3248  const BlockLength length = 6;
3249 
3250  return fixedStr<length>(offset);
3251  }
3252 
3253  /// Product Code within Security Group specified.
3254  StrRef asset() const
3255  {
3256  const BlockLength offset = 14;
3257  const BlockLength length = 6;
3258 
3259  return fixedStr<length>(offset);
3260  }
3261 
3262  /// If this tag is present, 35=f message is sent for the
3263  /// instrument.
3264  bool securityId(Int32& value) const
3265  {
3266  typedef NullInt32 Null;
3267 
3268  const BlockLength offset = 20;
3269 
3270  return ordinary(value, offset, Null());
3271  }
3272 
3273  /// Trade Session Date.
3275  {
3276  typedef NullLocalMktDate Null;
3277  typedef LocalMktDate FieldValue;
3278 
3279  const BlockLength offset = 24;
3280 
3281  FieldValue fieldValue;
3282 
3283  if (ordinary(fieldValue, offset, Null()))
3284  {
3285  value = localMktDateToTimestamp(fieldValue);
3286  return true;
3287  }
3288  return false;
3289  }
3290 
3291  /// Bitmap field of eight Boolean type indicators reflecting
3292  /// the end of updates for a given Globex event.
3294  {
3295  const BlockLength offset = 26;
3296 
3297  return ordinary<MatchEventIndicator>(offset);
3298  }
3299 
3300  /// Identifies the trading status applicable to the instrument
3301  /// or Security Group.
3302  bool
3305  {
3306  typedef NullUInt8 Null;
3307 
3308  const BlockLength offset = 27;
3309 
3310  return enumeration<SecurityTradingStatus>(value, offset, Null());
3311  }
3312 
3313  /// Identifies the reason for the status change.
3315  {
3316  const BlockLength offset = 28;
3317 
3318  return enumeration<HaltReason>(offset);
3319  }
3320 
3321  /// Identifies an additional event or a rule related to the
3322  /// status.
3325  {
3326  const BlockLength offset = 29;
3327 
3328  return enumeration<SecurityTradingEvent>(offset);
3329  }
3330 
3331  /// Size of message body in bytes.
3334  {
3335  return 30;
3336  }
3337 
3338  /// Returns class name.
3340  static const Char* className()
3341  {
3342  return "SecurityStatus30";
3343  }
3344 
3345  /// FIX message type.
3347  static StrRef fixType()
3348  {
3349  return toStrRef("f");
3350  }
3351 };
3352 
3353 /// MDIncrementalRefreshBook.
3356 : BinaryMessage
3357 {
3358  /// Message template ID from SBE schema.
3359  enum { TemplateId = 46 };
3360 
3361  /// Number of entries in Market Data message.
3362  /// Entry of Entry repeating group.
3365  <
3367  >
3368  {
3369  /// Aliases base class type.
3370  typedef
3372  <
3374  >
3376 
3377  /// Initializes blank instance.
3379  {
3380  }
3381 
3382  /// Initializes instance of given
3383  /// version over given memory block.
3385  const void* data,
3386  EncodedLength length,
3387  SchemaVersion version)
3388  : Base(data, length, version)
3389  {
3390  if (length < blockLength(version))
3391  throwBadBinaryData(className());
3392  }
3393 
3394  /// Market Data entry price.
3395  bool entryPx(Decimal& value) const
3396  {
3397  typedef NullPRICE9 Null;
3398 
3399  const BlockLength offset = 0;
3400 
3401  return decimal(value, offset, Null());
3402  }
3403 
3404  /// Market Data entry size.
3405  bool entrySize(Int32& value) const
3406  {
3407  typedef NullInt32 Null;
3408 
3409  const BlockLength offset = 8;
3410 
3411  return ordinary(value, offset, Null());
3412  }
3413 
3414  /// Security ID.
3416  {
3417  const BlockLength offset = 12;
3418 
3419  return ordinary<Int32>(offset);
3420  }
3421 
3422  /// Market Data entry sequence number per instrument update.
3423  UInt32 rptSeq() const
3424  {
3425  const BlockLength offset = 16;
3426 
3427  return ordinary<UInt32>(offset);
3428  }
3429 
3430  /// In Book entry - aggregate number of orders at given price
3431  /// level.
3433  {
3434  typedef NullInt32 Null;
3435 
3436  const BlockLength offset = 20;
3437 
3438  return ordinary(value, offset, Null());
3439  }
3440 
3441  /// Aggregate book level.
3443  {
3444  const BlockLength offset = 24;
3445 
3446  return ordinary<UInt8>(offset);
3447  }
3448 
3449  /// Market Data update action.
3451  {
3452  const BlockLength offset = 25;
3453 
3454  return enumeration<UpdateAction>(offset);
3455  }
3456 
3457  /// Market Data entry type.
3459  {
3460  const BlockLength offset = 26;
3461 
3462  return enumeration<EntryTypeBook>(offset);
3463  }
3464 
3465  /// Tradeable qty.
3467  {
3468  typedef NullInt32 Null;
3469 
3470  const BlockLength offset = 27;
3471  const SchemaVersion since = 10;
3472 
3473  return ordinary(value, offset, Null(), since);
3474  }
3475 
3476  /// Returns size of entry body in bytes
3477  /// for given version of message template.
3480  {
3481  if (version >= 10)
3482  return 31;
3483 
3484  return 27;
3485  }
3486 
3487  /// Entity class name.
3489  static const Char* className()
3490  {
3491  return "IncrementalRefreshBook46.Entry";
3492  }
3493  };
3494 
3495  /// Repeating group containing Entry entries.
3496  typedef
3499 
3500  /// Number of OrderID entries.
3501  /// Entry of OrderIDEntry repeating group.
3504  <
3506  >
3507  {
3508  /// Aliases base class type.
3509  typedef
3511  <
3513  >
3515 
3516  /// Initializes blank instance.
3518  {
3519  }
3520 
3521  /// Initializes instance of given
3522  /// version over given memory block.
3524  const void* data,
3525  EncodedLength length,
3526  SchemaVersion version)
3527  : Base(data, length, version)
3528  {
3529  if (length < blockLength(version))
3530  throwBadBinaryData(className());
3531  }
3532 
3533  /// Unique Order ID.
3534  UInt64 orderId() const
3535  {
3536  const BlockLength offset = 0;
3537 
3538  return ordinary<UInt64>(offset);
3539  }
3540 
3541  /// Order priority for execution on the order book.
3543  {
3544  typedef NullUInt64 Null;
3545 
3546  const BlockLength offset = 8;
3547 
3548  return ordinary(value, offset, Null());
3549  }
3550 
3551  /// Visible qty of order.
3552  bool displayQty(Int32& value) const
3553  {
3554  typedef NullInt32 Null;
3555 
3556  const BlockLength offset = 16;
3557 
3558  return ordinary(value, offset, Null());
3559  }
3560 
3561  /// Reference to corresponding Price and Security ID, sequence
3562  /// of MD entry in the message.
3563  bool referenceId(UInt8& value) const
3564  {
3565  typedef NullUInt8 Null;
3566 
3567  const BlockLength offset = 20;
3568 
3569  return ordinary(value, offset, Null());
3570  }
3571 
3572  /// Order book update action to be applied to the order
3573  /// referenced by OrderID.
3575  {
3576  const BlockLength offset = 21;
3577 
3578  return enumeration<OrderUpdateAction>(offset);
3579  }
3580 
3581  /// Returns size of entry body in bytes
3582  /// for given version of message template.
3585  {
3586  return 22;
3587  }
3588 
3589  /// Entity class name.
3591  static const Char* className()
3592  {
3593  return "IncrementalRefreshBook46.OrderIDEntry";
3594  }
3595  };
3596 
3597  /// Repeating group containing OrderIDEntry entries.
3598  typedef
3601 
3602  /// Initializes blank instance.
3604  {
3605  }
3606 
3607  /// Initializes instance over given memory block.
3609  const void* data,
3610  EncodedLength length)
3611  : BinaryMessage(data, length)
3612  {
3613  assert(TemplateId == templateId());
3614 
3615  if (length < blockLength(version()))
3616  throwBadBinaryData(className());
3617  }
3618 
3619  /// Start of event processing time in number of nanoseconds
3620  /// since Unix epoch.
3622  {
3623  const BlockLength offset = 0;
3624 
3625  return ordinary<Timestamp>(offset);
3626  }
3627 
3628  /// Bitmap field of eight Boolean type indicators reflecting
3629  /// the end of updates for a given Globex event.
3631  {
3632  const BlockLength offset = 8;
3633 
3634  return ordinary<MatchEventIndicator>(offset);
3635  }
3636 
3637  /// Returns instance of Entries repeating group.
3639  {
3640  return
3641  groups().
3642  head<Entries>();
3643  }
3644 
3645  /// Returns instance of OrderIDEntries repeating group.
3647  {
3648  return
3649  groups().
3650  tail<Entries>().
3651  head<OrderIDEntries>();
3652  }
3653 
3654  /// Size of message body in bytes.
3657  {
3658  return 9;
3659  }
3660 
3661  /// Returns class name.
3663  static const Char* className()
3664  {
3665  return "IncrementalRefreshBook46";
3666  }
3667 
3668  /// FIX message type.
3670  static StrRef fixType()
3671  {
3672  return toStrRef("X");
3673  }
3674 };
3675 
3676 /// MDIncrementalRefreshDailyStatistics.
3679 : BinaryMessage
3680 {
3681  /// Message template ID from SBE schema.
3682  enum { TemplateId = 49 };
3683 
3684  /// Number of entries in Market Data message.
3685  /// Entry of Entry repeating group.
3688  <
3690  >
3691  {
3692  /// Aliases base class type.
3693  typedef
3695  <
3697  >
3699 
3700  /// Initializes blank instance.
3702  {
3703  }
3704 
3705  /// Initializes instance of given
3706  /// version over given memory block.
3708  const void* data,
3709  EncodedLength length,
3710  SchemaVersion version)
3711  : Base(data, length, version)
3712  {
3713  if (length < blockLength(version))
3714  throwBadBinaryData(className());
3715  }
3716 
3717  /// Market Data entry price.
3718  bool entryPx(Decimal& value) const
3719  {
3720  typedef NullPRICE9 Null;
3721 
3722  const BlockLength offset = 0;
3723 
3724  return decimal(value, offset, Null());
3725  }
3726 
3727  /// Market Data entry size.
3728  bool entrySize(Int32& value) const
3729  {
3730  typedef NullInt32 Null;
3731 
3732  const BlockLength offset = 8;
3733 
3734  return ordinary(value, offset, Null());
3735  }
3736 
3737  /// Security ID.
3739  {
3740  const BlockLength offset = 12;
3741 
3742  return ordinary<Int32>(offset);
3743  }
3744 
3745  /// Market Data entry sequence number per instrument update.
3746  UInt32 rptSeq() const
3747  {
3748  const BlockLength offset = 16;
3749 
3750  return ordinary<UInt32>(offset);
3751  }
3752 
3753  /// Indicates trade session date corresponding to a statistic
3754  /// entry.
3756  {
3757  typedef NullLocalMktDate Null;
3758  typedef LocalMktDate FieldValue;
3759 
3760  const BlockLength offset = 20;
3761 
3762  FieldValue fieldValue;
3763 
3764  if (ordinary(fieldValue, offset, Null()))
3765  {
3766  value = localMktDateToTimestamp(fieldValue);
3767  return true;
3768  }
3769  return false;
3770  }
3771 
3772  /// Bitmap field of eight Boolean type indicators representing
3773  /// settlement price type.
3775  {
3776  const BlockLength offset = 22;
3777 
3778  return ordinary<SettlPriceType>(offset);
3779  }
3780 
3781  /// Market Data update action.
3783  {
3784  const BlockLength offset = 23;
3785 
3786  return enumeration<UpdateAction>(offset);
3787  }
3788 
3789  /// Market Data entry type.
3791  entryType() const
3792  {
3793  const BlockLength offset = 24;
3794 
3795  return enumeration<EntryTypeDailyStatistics>(offset);
3796  }
3797 
3798  /// Returns size of entry body in bytes
3799  /// for given version of message template.
3802  {
3803  return 25;
3804  }
3805 
3806  /// Entity class name.
3808  static const Char* className()
3809  {
3810  return "IncrementalRefreshDailyStatistics49.Entry";
3811  }
3812  };
3813 
3814  /// Repeating group containing Entry entries.
3815  typedef
3818 
3819  /// Initializes blank instance.
3821  {
3822  }
3823 
3824  /// Initializes instance over given memory block.
3826  const void* data,
3827  EncodedLength length)
3828  : BinaryMessage(data, length)
3829  {
3830  assert(TemplateId == templateId());
3831 
3832  if (length < blockLength(version()))
3833  throwBadBinaryData(className());
3834  }
3835 
3836  /// Start of event processing time in number of nanoseconds
3837  /// since Unix epoch.
3839  {
3840  const BlockLength offset = 0;
3841 
3842  return ordinary<Timestamp>(offset);
3843  }
3844 
3845  /// Bitmap field of eight Boolean type indicators reflecting
3846  /// the end of updates for a given Globex event.
3848  {
3849  const BlockLength offset = 8;
3850 
3851  return ordinary<MatchEventIndicator>(offset);
3852  }
3853 
3854  /// Returns instance of Entries repeating group.
3856  {
3857  return
3858  groups().
3859  head<Entries>();
3860  }
3861 
3862  /// Size of message body in bytes.
3865  {
3866  return 9;
3867  }
3868 
3869  /// Returns class name.
3871  static const Char* className()
3872  {
3873  return "IncrementalRefreshDailyStatistics49";
3874  }
3875 
3876  /// FIX message type.
3878  static StrRef fixType()
3879  {
3880  return toStrRef("X");
3881  }
3882 };
3883 
3884 /// MDIncrementalRefreshLimitsBanding.
3887 : BinaryMessage
3888 {
3889  /// Message template ID from SBE schema.
3890  enum { TemplateId = 50 };
3891 
3892  /// Number of entries in Market Data message.
3893  /// Entry of Entry repeating group.
3896  <
3898  >
3899  {
3900  /// Aliases base class type.
3901  typedef
3903  <
3905  >
3907 
3908  /// Initializes blank instance.
3910  {
3911  }
3912 
3913  /// Initializes instance of given
3914  /// version over given memory block.
3916  const void* data,
3917  EncodedLength length,
3918  SchemaVersion version)
3919  : Base(data, length, version)
3920  {
3921  if (length < blockLength(version))
3922  throwBadBinaryData(className());
3923  }
3924 
3925  /// Upper price threshold for the instrument.
3927  {
3928  typedef NullPRICE9 Null;
3929 
3930  const BlockLength offset = 0;
3931 
3932  return decimal(value, offset, Null());
3933  }
3934 
3935  /// Lower price threshold for the instrument.
3937  {
3938  typedef NullPRICE9 Null;
3939 
3940  const BlockLength offset = 8;
3941 
3942  return decimal(value, offset, Null());
3943  }
3944 
3945  /// Differential static value for price banding.
3947  {
3948  typedef NullPRICE9 Null;
3949 
3950  const BlockLength offset = 16;
3951 
3952  return decimal(value, offset, Null());
3953  }
3954 
3955  /// Security ID.
3957  {
3958  const BlockLength offset = 24;
3959 
3960  return ordinary<Int32>(offset);
3961  }
3962 
3963  /// MD Entry sequence number per instrument update.
3964  UInt32 rptSeq() const
3965  {
3966  const BlockLength offset = 28;
3967 
3968  return ordinary<UInt32>(offset);
3969  }
3970 
3971  /// Market Data entry update action. In order to delete
3972  /// banding value, high or low limit, the deleted price field
3973  /// is populated with a NULL.
3975  {
3976  return UpdateActionNew();
3977  }
3978 
3979  /// Market Data entry type.
3981  {
3982  return EntryTypeLimits();
3983  }
3984 
3985  /// Returns size of entry body in bytes
3986  /// for given version of message template.
3989  {
3990  return 32;
3991  }
3992 
3993  /// Entity class name.
3995  static const Char* className()
3996  {
3997  return "IncrementalRefreshLimitsBanding50.Entry";
3998  }
3999  };
4000 
4001  /// Repeating group containing Entry entries.
4002  typedef
4005 
4006  /// Initializes blank instance.
4008  {
4009  }
4010 
4011  /// Initializes instance over given memory block.
4013  const void* data,
4014  EncodedLength length)
4015  : BinaryMessage(data, length)
4016  {
4017  assert(TemplateId == templateId());
4018 
4019  if (length < blockLength(version()))
4020  throwBadBinaryData(className());
4021  }
4022 
4023  /// Start of event processing time in number of nanoseconds
4024  /// since Unix epoch.
4026  {
4027  const BlockLength offset = 0;
4028 
4029  return ordinary<Timestamp>(offset);
4030  }
4031 
4032  /// Bitmap field of eight Boolean type indicators reflecting
4033  /// the end of updates for a given Globex event.
4035  {
4036  const BlockLength offset = 8;
4037 
4038  return ordinary<MatchEventIndicator>(offset);
4039  }
4040 
4041  /// Returns instance of Entries repeating group.
4043  {
4044  return
4045  groups().
4046  head<Entries>();
4047  }
4048 
4049  /// Size of message body in bytes.
4052  {
4053  return 9;
4054  }
4055 
4056  /// Returns class name.
4058  static const Char* className()
4059  {
4060  return "IncrementalRefreshLimitsBanding50";
4061  }
4062 
4063  /// FIX message type.
4065  static StrRef fixType()
4066  {
4067  return toStrRef("X");
4068  }
4069 };
4070 
4071 /// MDIncrementalRefreshSessionStatistics.
4074 : BinaryMessage
4075 {
4076  /// Message template ID from SBE schema.
4077  enum { TemplateId = 51 };
4078 
4079  /// Number of entries in Market Data message.
4080  /// Entry of Entry repeating group.
4083  <
4085  >
4086  {
4087  /// Aliases base class type.
4088  typedef
4090  <
4092  >
4094 
4095  /// Initializes blank instance.
4097  {
4098  }
4099 
4100  /// Initializes instance of given
4101  /// version over given memory block.
4103  const void* data,
4104  EncodedLength length,
4105  SchemaVersion version)
4106  : Base(data, length, version)
4107  {
4108  if (length < blockLength(version))
4109  throwBadBinaryData(className());
4110  }
4111 
4112  /// Market Data entry price.
4114  {
4115  const BlockLength offset = 0;
4116 
4117  return decimal<PRICE9>(offset);
4118  }
4119 
4120  /// Security ID.
4122  {
4123  const BlockLength offset = 8;
4124 
4125  return ordinary<Int32>(offset);
4126  }
4127 
4128  /// MD Entry sequence number per instrument update.
4129  UInt32 rptSeq() const
4130  {
4131  const BlockLength offset = 12;
4132 
4133  return ordinary<UInt32>(offset);
4134  }
4135 
4136  /// Flag describing IOP and Open Price entries.
4137  bool
4140  {
4141  typedef NullUInt8 Null;
4142 
4143  const BlockLength offset = 16;
4144 
4145  return enumeration<OpenCloseSettlFlag>(value, offset, Null());
4146  }
4147 
4148  /// Market Data update action.
4150  {
4151  const BlockLength offset = 17;
4152 
4153  return enumeration<UpdateAction>(offset);
4154  }
4155 
4156  /// Market Data entry type.
4158  entryType() const
4159  {
4160  const BlockLength offset = 18;
4161 
4162  return enumeration<EntryTypeStatistics>(offset);
4163  }
4164 
4165  /// Indicative Opening Quantity.
4166  bool entrySize(Int32& value) const
4167  {
4168  typedef NullInt32 Null;
4169 
4170  const BlockLength offset = 19;
4171 
4172  return ordinary(value, offset, Null());
4173  }
4174 
4175  /// Returns size of entry body in bytes
4176  /// for given version of message template.
4179  {
4180  return 23;
4181  }
4182 
4183  /// Entity class name.
4185  static const Char* className()
4186  {
4187  return "IncrementalRefreshSessionStatistics51.Entry";
4188  }
4189  };
4190 
4191  /// Repeating group containing Entry entries.
4192  typedef
4195 
4196  /// Initializes blank instance.
4198  {
4199  }
4200 
4201  /// Initializes instance over given memory block.
4203  const void* data,
4204  EncodedLength length)
4205  : BinaryMessage(data, length)
4206  {
4207  assert(TemplateId == templateId());
4208 
4209  if (length < blockLength(version()))
4210  throwBadBinaryData(className());
4211  }
4212 
4213  /// Start of event processing time in number of nanoseconds
4214  /// since Unix epoch.
4216  {
4217  const BlockLength offset = 0;
4218 
4219  return ordinary<Timestamp>(offset);
4220  }
4221 
4222  /// Bitmap field of eight Boolean type indicators reflecting
4223  /// the end of updates for a given Globex event.
4225  {
4226  const BlockLength offset = 8;
4227 
4228  return ordinary<MatchEventIndicator>(offset);
4229  }
4230 
4231  /// Returns instance of Entries repeating group.
4233  {
4234  return
4235  groups().
4236  head<Entries>();
4237  }
4238 
4239  /// Size of message body in bytes.
4242  {
4243  return 9;
4244  }
4245 
4246  /// Returns class name.
4248  static const Char* className()
4249  {
4250  return "IncrementalRefreshSessionStatistics51";
4251  }
4252 
4253  /// FIX message type.
4255  static StrRef fixType()
4256  {
4257  return toStrRef("X");
4258  }
4259 };
4260 
4261 /// MDIncrementalRefreshVolume.
4264 : BinaryMessage
4265 {
4266  /// Message template ID from SBE schema.
4267  enum { TemplateId = 37 };
4268 
4269  /// Number of entries in Market Data message.
4270  /// Entry of Entry repeating group.
4273  <
4275  >
4276  {
4277  /// Aliases base class type.
4278  typedef
4280  <
4282  >
4284 
4285  /// Initializes blank instance.
4287  {
4288  }
4289 
4290  /// Initializes instance of given
4291  /// version over given memory block.
4293  const void* data,
4294  EncodedLength length,
4295  SchemaVersion version)
4296  : Base(data, length, version)
4297  {
4298  if (length < blockLength(version))
4299  throwBadBinaryData(className());
4300  }
4301 
4302  /// Cumulative traded volume.
4304  {
4305  const BlockLength offset = 0;
4306 
4307  return ordinary<Int32>(offset);
4308  }
4309 
4310  /// Security ID.
4312  {
4313  const BlockLength offset = 4;
4314 
4315  return ordinary<Int32>(offset);
4316  }
4317 
4318  /// Market Data entry sequence number per instrument update.
4319  UInt32 rptSeq() const
4320  {
4321  const BlockLength offset = 8;
4322 
4323  return ordinary<UInt32>(offset);
4324  }
4325 
4326  /// Market Data update action.
4328  {
4329  const BlockLength offset = 12;
4330 
4331  return enumeration<UpdateAction>(offset);
4332  }
4333 
4334  /// Electronic Volume entry provides cumulative session trade
4335  /// volume updated with the event.
4337  {
4338  return EntryTypeVol();
4339  }
4340 
4341  /// Returns size of entry body in bytes
4342  /// for given version of message template.
4345  {
4346  return 13;
4347  }
4348 
4349  /// Entity class name.
4351  static const Char* className()
4352  {
4353  return "IncrementalRefreshVolume37.Entry";
4354  }
4355  };
4356 
4357  /// Repeating group containing Entry entries.
4358  typedef
4361 
4362  /// Initializes blank instance.
4364  {
4365  }
4366 
4367  /// Initializes instance over given memory block.
4369  const void* data,
4370  EncodedLength length)
4371  : BinaryMessage(data, length)
4372  {
4373  assert(TemplateId == templateId());
4374 
4375  if (length < blockLength(version()))
4376  throwBadBinaryData(className());
4377  }
4378 
4379  /// Start of event processing time in number of nanoseconds
4380  /// since Unix epoch.
4382  {
4383  const BlockLength offset = 0;
4384 
4385  return ordinary<Timestamp>(offset);
4386  }
4387 
4388  /// Bitmap field of eight Boolean type indicators reflecting
4389  /// the end of updates for a given Globex event.
4391  {
4392  const BlockLength offset = 8;
4393 
4394  return ordinary<MatchEventIndicator>(offset);
4395  }
4396 
4397  /// Returns instance of Entries repeating group.
4399  {
4400  return
4401  groups().
4402  head<Entries>();
4403  }
4404 
4405  /// Size of message body in bytes.
4408  {
4409  return 9;
4410  }
4411 
4412  /// Returns class name.
4414  static const Char* className()
4415  {
4416  return "IncrementalRefreshVolume37";
4417  }
4418 
4419  /// FIX message type.
4421  static StrRef fixType()
4422  {
4423  return toStrRef("X");
4424  }
4425 };
4426 
4427 /// SnapshotFullRefresh.
4430 : BinaryMessage
4431 {
4432  /// Message template ID from SBE schema.
4433  enum { TemplateId = 52 };
4434 
4435  /// Number of entries in Market Data message.
4436  /// Entry of Entry repeating group.
4439  <
4441  >
4442  {
4443  /// Aliases base class type.
4444  typedef
4446  <
4448  >
4450 
4451  /// Initializes blank instance.
4453  {
4454  }
4455 
4456  /// Initializes instance of given
4457  /// version over given memory block.
4459  const void* data,
4460  EncodedLength length,
4461  SchemaVersion version)
4462  : Base(data, length, version)
4463  {
4464  if (length < blockLength(version))
4465  throwBadBinaryData(className());
4466  }
4467 
4468  /// Market Data entry price.
4469  bool entryPx(Decimal& value) const
4470  {
4471  typedef NullPRICE9 Null;
4472 
4473  const BlockLength offset = 0;
4474 
4475  return decimal(value, offset, Null());
4476  }
4477 
4478  /// Market Data entry quantity.
4479  bool entrySize(Int32& value) const
4480  {
4481  typedef NullInt32 Null;
4482 
4483  const BlockLength offset = 8;
4484 
4485  return ordinary(value, offset, Null());
4486  }
4487 
4488  /// Aggregate number of orders at the given price level.
4490  {
4491  typedef NullInt32 Null;
4492 
4493  const BlockLength offset = 12;
4494 
4495  return ordinary(value, offset, Null());
4496  }
4497 
4498  /// Aggregate book position.
4499  bool priceLevel(Int8& value) const
4500  {
4501  typedef NullInt8 Null;
4502 
4503  const BlockLength offset = 16;
4504 
4505  return ordinary(value, offset, Null());
4506  }
4507 
4508  /// Indicates the date of trade session corresponding to a
4509  /// statistic entry.
4511  {
4512  typedef NullLocalMktDate Null;
4513  typedef LocalMktDate FieldValue;
4514 
4515  const BlockLength offset = 17;
4516 
4517  FieldValue fieldValue;
4518 
4519  if (ordinary(fieldValue, offset, Null()))
4520  {
4521  value = localMktDateToTimestamp(fieldValue);
4522  return true;
4523  }
4524  return false;
4525  }
4526 
4527  /// Flag describing Open Price entry.
4528  bool
4531  {
4532  typedef NullUInt8 Null;
4533 
4534  const BlockLength offset = 19;
4535 
4536  return enumeration<OpenCloseSettlFlag>(value, offset, Null());
4537  }
4538 
4539  /// Bitmap field of eight Boolean type indicators representing
4540  /// settlement price type.
4542  {
4543  const BlockLength offset = 20;
4544 
4545  return ordinary<SettlPriceType>(offset);
4546  }
4547 
4548  /// Market Data entry type.
4550  {
4551  const BlockLength offset = 21;
4552 
4553  return enumeration<EntryType>(offset);
4554  }
4555 
4556  /// Returns size of entry body in bytes
4557  /// for given version of message template.
4560  {
4561  return 22;
4562  }
4563 
4564  /// Entity class name.
4566  static const Char* className()
4567  {
4568  return "SnapshotFullRefresh52.Entry";
4569  }
4570  };
4571 
4572  /// Repeating group containing Entry entries.
4573  typedef
4576 
4577  /// Initializes blank instance.
4579  {
4580  }
4581 
4582  /// Initializes instance over given memory block.
4584  const void* data,
4585  EncodedLength length)
4586  : BinaryMessage(data, length)
4587  {
4588  assert(TemplateId == templateId());
4589 
4590  if (length < blockLength(version()))
4591  throwBadBinaryData(className());
4592  }
4593 
4594  /// Sequence number of the last Incremental feed packet
4595  /// processed. This value is used to synchronize the snapshot
4596  /// loop with the real-time feed.
4598  {
4599  const BlockLength offset = 0;
4600 
4601  return ordinary<UInt32>(offset);
4602  }
4603 
4604  /// Total number of messages replayed in the loop.
4606  {
4607  const BlockLength offset = 4;
4608 
4609  return ordinary<UInt32>(offset);
4610  }
4611 
4612  /// Security ID.
4614  {
4615  const BlockLength offset = 8;
4616 
4617  return ordinary<Int32>(offset);
4618  }
4619 
4620  /// Sequence number of the last Market Data entry processed
4621  /// for the instrument.
4622  UInt32 rptSeq() const
4623  {
4624  const BlockLength offset = 12;
4625 
4626  return ordinary<UInt32>(offset);
4627  }
4628 
4629  /// Timestamp of the last event security participated in, sent
4630  /// as number of nanoseconds since Unix epoch.
4632  {
4633  const BlockLength offset = 16;
4634 
4635  return ordinary<Timestamp>(offset);
4636  }
4637 
4638  /// UTC Date and time of last Security Definition add, update
4639  /// or delete on a given Market Data channel.
4641  {
4642  const BlockLength offset = 24;
4643 
4644  return ordinary<Timestamp>(offset);
4645  }
4646 
4647  /// Trade session date sent as number of days since Unix epoch.
4649  {
4650  typedef NullLocalMktDate Null;
4651  typedef LocalMktDate FieldValue;
4652 
4653  const BlockLength offset = 32;
4654 
4655  FieldValue fieldValue;
4656 
4657  if (ordinary(fieldValue, offset, Null()))
4658  {
4659  value = localMktDateToTimestamp(fieldValue);
4660  return true;
4661  }
4662  return false;
4663  }
4664 
4665  /// Identifies the current trading state of the instrument.
4666  bool
4669  {
4670  typedef NullUInt8 Null;
4671 
4672  const BlockLength offset = 34;
4673 
4674  return enumeration<SecurityTradingStatus>(value, offset, Null());
4675  }
4676 
4677  /// Upper price threshold for the instrument.
4679  {
4680  typedef NullPRICE9 Null;
4681 
4682  const BlockLength offset = 35;
4683 
4684  return decimal(value, offset, Null());
4685  }
4686 
4687  /// Lower price threshold for the instrument.
4689  {
4690  typedef NullPRICE9 Null;
4691 
4692  const BlockLength offset = 43;
4693 
4694  return decimal(value, offset, Null());
4695  }
4696 
4697  /// Differential value for price banding.
4699  {
4700  typedef NullPRICE9 Null;
4701 
4702  const BlockLength offset = 51;
4703 
4704  return decimal(value, offset, Null());
4705  }
4706 
4707  /// Returns instance of Entries repeating group.
4709  {
4710  return
4711  groups().
4712  head<Entries>();
4713  }
4714 
4715  /// Size of message body in bytes.
4718  {
4719  return 59;
4720  }
4721 
4722  /// Returns class name.
4724  static const Char* className()
4725  {
4726  return "SnapshotFullRefresh52";
4727  }
4728 
4729  /// FIX message type.
4731  static StrRef fixType()
4732  {
4733  return toStrRef("W");
4734  }
4735 };
4736 
4737 /// QuoteRequest.
4740 : BinaryMessage
4741 {
4742  /// Message template ID from SBE schema.
4743  enum { TemplateId = 39 };
4744 
4745  /// Indicates the number of repeating symbols specified.
4746  /// Entry of RelatedSymEntry repeating group.
4749  <
4751  >
4752  {
4753  /// Aliases base class type.
4754  typedef
4756  <
4758  >
4760 
4761  /// Initializes blank instance.
4763  {
4764  }
4765 
4766  /// Initializes instance of given
4767  /// version over given memory block.
4769  const void* data,
4770  EncodedLength length,
4771  SchemaVersion version)
4772  : Base(data, length, version)
4773  {
4774  if (length < blockLength(version))
4775  throwBadBinaryData(className());
4776  }
4777 
4778  /// Instrument Name or Symbol.
4779  StrRef symbol() const
4780  {
4781  const BlockLength offset = 0;
4782  const BlockLength length = 20;
4783 
4784  return fixedStr<length>(offset);
4785  }
4786 
4787  /// Security ID.
4789  {
4790  const BlockLength offset = 20;
4791 
4792  return ordinary<Int32>(offset);
4793  }
4794 
4795  /// Quantity requested.
4796  bool orderQty(Int32& value) const
4797  {
4798  typedef NullInt32 Null;
4799 
4800  const BlockLength offset = 24;
4801 
4802  return ordinary(value, offset, Null());
4803  }
4804 
4805  /// Type of quote requested.
4806  Int8 quoteType() const
4807  {
4808  const BlockLength offset = 28;
4809 
4810  return ordinary<Int8>(offset);
4811  }
4812 
4813  /// Side requested.
4814  bool side(Int8& value) const
4815  {
4816  typedef NullInt8 Null;
4817 
4818  const BlockLength offset = 29;
4819 
4820  return ordinary(value, offset, Null());
4821  }
4822 
4823  /// Returns size of entry body in bytes
4824  /// for given version of message template.
4827  {
4828  return 30;
4829  }
4830 
4831  /// Entity class name.
4833  static const Char* className()
4834  {
4835  return "QuoteRequest39.RelatedSymEntry";
4836  }
4837  };
4838 
4839  /// Repeating group containing RelatedSymEntry entries.
4840  typedef
4843 
4844  /// Initializes blank instance.
4846  {
4847  }
4848 
4849  /// Initializes instance over given memory block.
4851  const void* data,
4852  EncodedLength length)
4853  : BinaryMessage(data, length)
4854  {
4855  assert(TemplateId == templateId());
4856 
4857  if (length < blockLength(version()))
4858  throwBadBinaryData(className());
4859  }
4860 
4861  /// Start of event processing time in number of nanoseconds
4862  /// since Unix epoch.
4864  {
4865  const BlockLength offset = 0;
4866 
4867  return ordinary<Timestamp>(offset);
4868  }
4869 
4870  /// Quote Request ID defined by the exchange.
4872  {
4873  const BlockLength offset = 8;
4874  const BlockLength length = 23;
4875 
4876  return fixedStr<length>(offset);
4877  }
4878 
4879  /// Bitmap field of eight Boolean type indicators reflecting
4880  /// the end of updates for a given Globex event.
4882  {
4883  const BlockLength offset = 31;
4884 
4885  return ordinary<MatchEventIndicator>(offset);
4886  }
4887 
4888  /// Returns instance of RelatedSym repeating group.
4890  {
4891  return
4892  groups().
4893  head<RelatedSym>();
4894  }
4895 
4896  /// Size of message body in bytes.
4899  {
4900  return 32;
4901  }
4902 
4903  /// Returns class name.
4905  static const Char* className()
4906  {
4907  return "QuoteRequest39";
4908  }
4909 
4910  /// FIX message type.
4912  static StrRef fixType()
4913  {
4914  return toStrRef("R");
4915  }
4916 };
4917 
4918 /// MDInstrumentDefinitionOption.
4921 : BinaryMessage
4922 {
4923  /// Message template ID from SBE schema.
4924  enum { TemplateId = 55 };
4925 
4926  /// Number of EventType entries.
4927  /// Entry of EventsEntry repeating group.
4930  <
4932  >
4933  {
4934  /// Aliases base class type.
4935  typedef
4937  <
4939  >
4941 
4942  /// Initializes blank instance.
4944  {
4945  }
4946 
4947  /// Initializes instance of given
4948  /// version over given memory block.
4950  const void* data,
4951  EncodedLength length,
4952  SchemaVersion version)
4953  : Base(data, length, version)
4954  {
4955  if (length < blockLength(version))
4956  throwBadBinaryData(className());
4957  }
4958 
4959  /// Code to represent the type of event.
4961  {
4962  const BlockLength offset = 0;
4963 
4964  return enumeration<EventType>(offset);
4965  }
4966 
4967  /// Date and Time of instument Activation or Expiration event
4968  /// sent as number of nanoseconds since Unix epoch.
4970  {
4971  const BlockLength offset = 1;
4972 
4973  return ordinary<Timestamp>(offset);
4974  }
4975 
4976  /// Returns size of entry body in bytes
4977  /// for given version of message template.
4980  {
4981  return 9;
4982  }
4983 
4984  /// Entity class name.
4986  static const Char* className()
4987  {
4988  return "InstrumentDefinitionOption55.EventsEntry";
4989  }
4990  };
4991 
4992  /// Repeating group containing EventsEntry entries.
4993  typedef
4996 
4997  /// Number of FeedType entries.
4998  /// Entry of FeedTypesEntry repeating group.
5001  <
5003  >
5004  {
5005  /// Aliases base class type.
5006  typedef
5008  <
5010  >
5012 
5013  /// Initializes blank instance.
5015  {
5016  }
5017 
5018  /// Initializes instance of given
5019  /// version over given memory block.
5021  const void* data,
5022  EncodedLength length,
5023  SchemaVersion version)
5024  : Base(data, length, version)
5025  {
5026  if (length < blockLength(version))
5027  throwBadBinaryData(className());
5028  }
5029 
5030  /// Describes a class of service for a given data feed. GBX-
5031  /// Real Book, GBI-Implied Book.
5033  {
5034  const BlockLength offset = 0;
5035  const BlockLength length = 3;
5036 
5037  return fixedStr<length>(offset);
5038  }
5039 
5040  /// Book depth.
5042  {
5043  const BlockLength offset = 3;
5044 
5045  return ordinary<Int8>(offset);
5046  }
5047 
5048  /// Returns size of entry body in bytes
5049  /// for given version of message template.
5052  {
5053  return 4;
5054  }
5055 
5056  /// Entity class name.
5058  static const Char* className()
5059  {
5060  return "InstrumentDefinitionOption55.FeedTypesEntry";
5061  }
5062  };
5063 
5064  /// Repeating group containing FeedTypesEntry entries.
5065  typedef
5068 
5069  /// Number of InstrAttribType entries.
5070  /// Entry of InstAttribEntry repeating group.
5073  <
5075  >
5076  {
5077  /// Aliases base class type.
5078  typedef
5080  <
5082  >
5084 
5085  /// Initializes blank instance.
5087  {
5088  }
5089 
5090  /// Initializes instance of given
5091  /// version over given memory block.
5093  const void* data,
5094  EncodedLength length,
5095  SchemaVersion version)
5096  : Base(data, length, version)
5097  {
5098  if (length < blockLength(version))
5099  throwBadBinaryData(className());
5100  }
5101 
5102  /// Instrument Eligibility Attributes.
5104  {
5105  return InstAttribType();
5106  }
5107 
5108  /// Bitmap field of 32 Boolean type Instrument eligibility
5109  /// flags.
5111  {
5112  const BlockLength offset = 0;
5113 
5114  return ordinary<InstAttribValue>(offset);
5115  }
5116 
5117  /// Returns size of entry body in bytes
5118  /// for given version of message template.
5121  {
5122  return 4;
5123  }
5124 
5125  /// Entity class name.
5127  static const Char* className()
5128  {
5129  return "InstrumentDefinitionOption55.InstAttribEntry";
5130  }
5131  };
5132 
5133  /// Repeating group containing InstAttribEntry entries.
5134  typedef
5137 
5138  /// Number of entries.
5139  /// Entry of LotTypeRulesEntry repeating group.
5142  <
5144  >
5145  {
5146  /// Aliases base class type.
5147  typedef
5149  <
5151  >
5153 
5154  /// Initializes blank instance.
5156  {
5157  }
5158 
5159  /// Initializes instance of given
5160  /// version over given memory block.
5162  const void* data,
5163  EncodedLength length,
5164  SchemaVersion version)
5165  : Base(data, length, version)
5166  {
5167  if (length < blockLength(version))
5168  throwBadBinaryData(className());
5169  }
5170 
5171  /// This tag is required to interpret the value in tag
5172  /// 1231-MinLotSize.
5173  Int8 lotType() const
5174  {
5175  const BlockLength offset = 0;
5176 
5177  return ordinary<Int8>(offset);
5178  }
5179 
5180  /// Minimum quantity accepted for order entry. If tag
5181  /// 1093-LotType=4, this value is the minimum quantity for
5182  /// order entry expressed in the applicable units, specified
5183  /// in tag 996-UnitOfMeasure, e.g. megawatts.
5184  bool minLotSize(Decimal& value) const
5185  {
5186  typedef NullDecimalQty Null;
5187 
5188  const BlockLength offset = 1;
5189 
5190  return decimal(value, offset, Null());
5191  }
5192 
5193  /// Returns size of entry body in bytes
5194  /// for given version of message template.
5197  {
5198  return 5;
5199  }
5200 
5201  /// Entity class name.
5203  static const Char* className()
5204  {
5205  return "InstrumentDefinitionOption55.LotTypeRulesEntry";
5206  }
5207  };
5208 
5209  /// Repeating group containing LotTypeRulesEntry entries.
5210  typedef
5213 
5214  /// Number of underlying instruments.
5215  /// Entry of UnderlyingsEntry repeating group.
5218  <
5220  >
5221  {
5222  /// Aliases base class type.
5223  typedef
5225  <
5227  >
5229 
5230  /// Initializes blank instance.
5232  {
5233  }
5234 
5235  /// Initializes instance of given
5236  /// version over given memory block.
5238  const void* data,
5239  EncodedLength length,
5240  SchemaVersion version)
5241  : Base(data, length, version)
5242  {
5243  if (length < blockLength(version))
5244  throwBadBinaryData(className());
5245  }
5246 
5247  /// Unique Instrument ID as qualified by the exchange per tag
5248  /// 305-UnderlyingSecurityIDSource.
5250  {
5251  const BlockLength offset = 0;
5252 
5253  return ordinary<Int32>(offset);
5254  }
5255 
5256  /// This value is always '8' for CME.
5258  {
5259  return SecurityIDSource();
5260  }
5261 
5262  /// Underlying Instrument Symbol (Contract Name).
5264  {
5265  const BlockLength offset = 4;
5266  const BlockLength length = 20;
5267 
5268  return fixedStr<length>(offset);
5269  }
5270 
5271  /// Returns size of entry body in bytes
5272  /// for given version of message template.
5275  {
5276  return 24;
5277  }
5278 
5279  /// Entity class name.
5281  static const Char* className()
5282  {
5283  return "InstrumentDefinitionOption55.UnderlyingsEntry";
5284  }
5285  };
5286 
5287  /// Repeating group containing UnderlyingsEntry entries.
5288  typedef
5291 
5292  /// Number of related instruments group.
5293  /// Entry of RelatedInstrumentsEntry repeating group.
5296  <
5298  >
5299  {
5300  /// Aliases base class type.
5301  typedef
5303  <
5305  >
5307 
5308  /// Initializes blank instance.
5310  {
5311  }
5312 
5313  /// Initializes instance of given
5314  /// version over given memory block.
5316  const void* data,
5317  EncodedLength length,
5318  SchemaVersion version)
5319  : Base(data, length, version)
5320  {
5321  if (length < blockLength(version))
5322  throwBadBinaryData(className());
5323  }
5324 
5325  /// Related Security ID.
5327  {
5328  const BlockLength offset = 0;
5329 
5330  return ordinary<Int32>(offset);
5331  }
5332 
5333  /// Related Security ID source.
5335  {
5336  return SecurityIDSource();
5337  }
5338 
5339  /// Related instrument Symbol.
5341  {
5342  const BlockLength offset = 4;
5343  const BlockLength length = 20;
5344 
5345  return fixedStr<length>(offset);
5346  }
5347 
5348  /// Returns size of entry body in bytes
5349  /// for given version of message template.
5352  {
5353  return 24;
5354  }
5355 
5356  /// Entity class name.
5358  static const Char* className()
5359  {
5360  return "InstrumentDefinitionOption55.RelatedInstrumentsEntry";
5361  }
5362  };
5363 
5364  /// Repeating group containing RelatedInstrumentsEntry entries.
5365  typedef
5368 
5369  /// Initializes blank instance.
5371  {
5372  }
5373 
5374  /// Initializes instance over given memory block.
5376  const void* data,
5377  EncodedLength length)
5378  : BinaryMessage(data, length)
5379  {
5380  assert(TemplateId == templateId());
5381 
5382  if (length < blockLength(version()))
5383  throwBadBinaryData(className());
5384  }
5385 
5386  /// Bitmap field of eight Boolean type indicators reflecting
5387  /// the end of updates for a given Globex event.
5389  {
5390  const BlockLength offset = 0;
5391 
5392  return ordinary<MatchEventIndicator>(offset);
5393  }
5394 
5395  /// Total number of instruments in the Replay loop. Used on
5396  /// Replay Feed only.
5398  {
5399  typedef NullUInt32 Null;
5400 
5401  const BlockLength offset = 1;
5402 
5403  return ordinary(value, offset, Null());
5404  }
5405 
5406  /// Last Security update action on Incremental feed, 'D' or
5407  /// 'M' is used when a mid-week deletion or modification (i.e.
5408  /// extension) occurs.
5411  {
5412  const BlockLength offset = 5;
5413 
5414  return enumeration<SecurityUpdateAction>(offset);
5415  }
5416 
5417  /// Timestamp of when the instrument was last added, modified
5418  /// or deleted.
5420  {
5421  const BlockLength offset = 6;
5422 
5423  return ordinary<Timestamp>(offset);
5424  }
5425 
5426  /// Identifies the current state of the instrument. The data
5427  /// is available in the Instrument Replay feed only.
5428  bool
5431  {
5432  typedef NullUInt8 Null;
5433 
5434  const BlockLength offset = 14;
5435 
5436  return enumeration<SecurityTradingStatus>(value, offset, Null());
5437  }
5438 
5439  /// The channel ID as defined in the XML Configuration file.
5440  Int16 applId() const
5441  {
5442  const BlockLength offset = 15;
5443 
5444  return ordinary<Int16>(offset);
5445  }
5446 
5447  /// Identifies the market segment, populated for all CME
5448  /// Globex instruments.
5450  {
5451  const BlockLength offset = 17;
5452 
5453  return ordinary<UInt8>(offset);
5454  }
5455 
5456  /// Indicates the product complex.
5458  {
5459  const BlockLength offset = 18;
5460 
5461  return ordinary<UInt8>(offset);
5462  }
5463 
5464  /// Exchange used to identify a security.
5466  {
5467  const BlockLength offset = 19;
5468  const BlockLength length = 4;
5469 
5470  return fixedStr<length>(offset);
5471  }
5472 
5473  /// Security Group Code.
5475  {
5476  const BlockLength offset = 23;
5477  const BlockLength length = 6;
5478 
5479  return fixedStr<length>(offset);
5480  }
5481 
5482  /// The underlying asset code also known as Product Code.
5483  StrRef asset() const
5484  {
5485  const BlockLength offset = 29;
5486  const BlockLength length = 6;
5487 
5488  return fixedStr<length>(offset);
5489  }
5490 
5491  /// Instrument Name or Symbol. Previously used as Instrument
5492  /// Group Code.
5493  StrRef symbol() const
5494  {
5495  const BlockLength offset = 35;
5496  const BlockLength length = 20;
5497 
5498  return fixedStr<length>(offset);
5499  }
5500 
5501  /// Unique Instrument ID.
5503  {
5504  const BlockLength offset = 55;
5505 
5506  return ordinary<Int32>(offset);
5507  }
5508 
5509  /// Identifies class or source of tag 48-SecurityID value.
5511  {
5512  return SecurityIDSource();
5513  }
5514 
5515  /// Security Type.
5517  {
5518  const BlockLength offset = 59;
5519  const BlockLength length = 6;
5520 
5521  return fixedStr<length>(offset);
5522  }
5523 
5524  /// ISO standard instrument categorization code.
5525  StrRef cfiCode() const
5526  {
5527  const BlockLength offset = 65;
5528  const BlockLength length = 6;
5529 
5530  return fixedStr<length>(offset);
5531  }
5532 
5533  /// Indicates whether an option instrument is a put or call.
5535  {
5536  const BlockLength offset = 71;
5537 
5538  return enumeration<PutOrCall>(offset);
5539  }
5540 
5541  /// This field provides the actual calendar date for contract
5542  /// maturity.
5544  {
5545  typedef NullMaturityMonthYear Null;
5546 
5547  const BlockLength offset = 72;
5548 
5549  return ordinary(value, offset, Null());
5550  }
5551 
5552  /// Identifies currency used for price.
5554  {
5555  const BlockLength offset = 77;
5556  const BlockLength length = 3;
5557 
5558  return fixedStr<length>(offset);
5559  }
5560 
5561  /// Strike Price for an option instrument.
5563  {
5564  typedef NullPRICE9 Null;
5565 
5566  const BlockLength offset = 80;
5567 
5568  return decimal(value, offset, Null());
5569  }
5570 
5571  /// Currency in which the StrikePrice is denominated.
5573  {
5574  const BlockLength offset = 88;
5575  const BlockLength length = 3;
5576 
5577  return fixedStr<length>(offset);
5578  }
5579 
5580  /// Identifies currency used for settlement, if different from
5581  /// trade price currency.