OnixS C++ CME MDP Premium Market Data Handler  5.8.3
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.
33 {
34  /// Message template ID from SBE schema.
35  enum
36  {
37  TemplateId = 57
38  };
39 
40  /// Number of repeating EventType entries.
41  /// Entry of EventsEntry repeating group.
42  struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
43  {
44  /// Aliases base class type.
46 
47  /// Initializes blank instance.
49 
50  /// Initializes instance of given
51  /// version over given memory block.
52  EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
53  : Base(data, length, version)
54  {
55  if (length < blockLength(version))
56  throwBadBinaryData(className());
57  }
58 
59  /// Code to represent the type of event.
61  {
62  const BlockLength offset = 0;
63 
64  return enumeration<EventType>(offset);
65  }
66 
67  /// Date and Time of instrument Activation or Expiration event
68  /// sent as number of nanoseconds since Unix epoch.
70  {
71  const BlockLength offset = 1;
72 
73  return ordinary<Timestamp>(offset);
74  }
75 
76  /// Returns size of entry body in bytes
77  /// for given version of message template.
80  {
81  return 9;
82  }
83 
84  /// Entity class name.
86  static const Char* className()
87  {
88  return "InstrumentDefinitionFixedIncome57.EventsEntry";
89  }
90  };
91 
92  /// Repeating group containing EventsEntry entries.
94 
95  /// Number of repeating FeedType repeating group entries.
96  /// Entry of FeedTypesEntry repeating group.
97  struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
98  {
99  /// Aliases base class type.
101 
102  /// Initializes blank instance.
104 
105  /// Initializes instance of given
106  /// version over given memory block.
107  FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
108  : Base(data, length, version)
109  {
110  if (length < blockLength(version))
111  throwBadBinaryData(className());
112  }
113 
114  /// Describes a class of service for a given data feed. GBX-
115  /// Real Book, GBI-Implied Book.
116  StrRef feedType() const
117  {
118  const BlockLength offset = 0;
119  const BlockLength length = 3;
120 
121  return fixedStr<length>(offset);
122  }
123 
124  /// book depth.
126  {
127  const BlockLength offset = 3;
128 
129  return ordinary<Int8>(offset);
130  }
131 
132  /// Returns size of entry body in bytes
133  /// for given version of message template.
136  {
137  return 4;
138  }
139 
140  /// Entity class name.
142  static const Char* className()
143  {
144  return "InstrumentDefinitionFixedIncome57.FeedTypesEntry";
145  }
146  };
147 
148  /// Repeating group containing FeedTypesEntry entries.
150 
151  /// Number of repeating InstrAttribType entries.
152  /// Entry of InstAttribEntry repeating group.
153  struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
154  {
155  /// Aliases base class type.
157 
158  /// Initializes blank instance.
160 
161  /// Initializes instance of given
162  /// version over given memory block.
163  InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
164  : Base(data, length, version)
165  {
166  if (length < blockLength(version))
167  throwBadBinaryData(className());
168  }
169 
170  /// Instrument eligibility attributes.
172  {
173  return InstAttribType();
174  }
175 
176  /// Bitmap field of 32 Boolean type instrument eligibility
177  /// flags.
179  {
180  const BlockLength offset = 0;
181 
182  return ordinary<InstAttribValue>(offset);
183  }
184 
185  /// Returns size of entry body in bytes
186  /// for given version of message template.
189  {
190  return 4;
191  }
192 
193  /// Entity class name.
195  static const Char* className()
196  {
197  return "InstrumentDefinitionFixedIncome57.InstAttribEntry";
198  }
199  };
200 
201  /// Repeating group containing InstAttribEntry entries.
203 
204  /// Number of entries.
205  /// Entry of LotTypeRulesEntry repeating group.
206  struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
207  {
208  /// Aliases base class type.
210 
211  /// Initializes blank instance.
213 
214  /// Initializes instance of given
215  /// version over given memory block.
216  LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
217  : Base(data, length, version)
218  {
219  if (length < blockLength(version))
220  throwBadBinaryData(className());
221  }
222 
223  /// This tag is required to interpret the value in tag
224  /// 1231-MinLotSize.
225  Int8 lotType() const
226  {
227  const BlockLength offset = 0;
228 
229  return ordinary<Int8>(offset);
230  }
231 
232  /// Minimum quantity accepted for order entry. If tag
233  /// 1093-LotType=4, this value is the minimum quantity for
234  /// order entry expressed in the applicable units, specified
235  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
236  /// 1093-LotType= 5, this value represents order qty increment.
237  bool minLotSize(Decimal& value) const
238  {
239  typedef NullDecimalQty Null;
240 
241  const BlockLength offset = 1;
242 
243  return decimal(value, offset, Null());
244  }
245 
246  /// Returns size of entry body in bytes
247  /// for given version of message template.
250  {
251  return 5;
252  }
253 
254  /// Entity class name.
256  static const Char* className()
257  {
258  return "InstrumentDefinitionFixedIncome57.LotTypeRulesEntry";
259  }
260  };
261 
262  /// Repeating group containing LotTypeRulesEntry entries.
264 
265  /// Initializes blank instance.
267 
268  /// Initializes instance over given memory block.
270  : BinaryMessage(data, length)
271  {
272  assert(TemplateId == templateId());
273 
274  const SchemaVersion current = version();
275  const SchemaVersion since = 10;
276 
277  if (current < since)
278  throwBadMessageVersion(className(), current, since);
279 
280  if (length < blockLength(current))
281  throwBadBinaryData(className());
282  }
283 
284  /// Bitmap field of eight Boolean type indicators reflecting
285  /// the end of updates for a given Globex event.
287  {
288  const BlockLength offset = 0;
289 
290  return ordinary<MatchEventIndicator>(offset);
291  }
292 
293  /// Total number of instruments in the Replay loop. Used on
294  /// Replay Feed only.
296  {
297  typedef NullUInt32 Null;
298 
299  const BlockLength offset = 1;
300 
301  return ordinary(value, offset, Null());
302  }
303 
304  /// Last Security update action on Incremental feed, 'D' or
305  /// 'M' is used when a mid-week deletion or modification (i.e.
306  /// extension) occurs.
308  {
309  const BlockLength offset = 5;
310 
311  return enumeration<SecurityUpdateAction>(offset);
312  }
313 
314  /// Timestamp of when the instrument was last added, modified
315  /// or deleted.
317  {
318  const BlockLength offset = 6;
319 
320  return ordinary<Timestamp>(offset);
321  }
322 
323  /// Identifies the current market state of the instrument.
325  {
326  typedef NullUInt8 Null;
327 
328  const BlockLength offset = 14;
329 
330  return enumeration<SecurityTradingStatus>(value, offset, Null());
331  }
332 
333  /// MD channel ID as defined in the XML Configuration file.
334  Int16 applId() const
335  {
336  const BlockLength offset = 15;
337 
338  return ordinary<Int16>(offset);
339  }
340 
341  /// Identifies the market segment for all CME Globex
342  /// instruments.
344  {
345  const BlockLength offset = 17;
346 
347  return ordinary<UInt8>(offset);
348  }
349 
350  /// Indicates the product complex.
352  {
353  const BlockLength offset = 18;
354 
355  return ordinary<UInt8>(offset);
356  }
357 
358  /// Exchange used to identify a security.
360  {
361  const BlockLength offset = 19;
362  const BlockLength length = 4;
363 
364  return fixedStr<length>(offset);
365  }
366 
367  /// Security Group Code.
369  {
370  const BlockLength offset = 23;
371  const BlockLength length = 6;
372 
373  return fixedStr<length>(offset);
374  }
375 
376  /// The underlying asset code also known as Product Code.
377  StrRef asset() const
378  {
379  const BlockLength offset = 29;
380  const BlockLength length = 6;
381 
382  return fixedStr<length>(offset);
383  }
384 
385  /// Instrument Name or Symbol.
386  StrRef symbol() const
387  {
388  const BlockLength offset = 35;
389  const BlockLength length = 20;
390 
391  return fixedStr<length>(offset);
392  }
393 
394  /// Unique instrument ID.
396  {
397  const BlockLength offset = 55;
398 
399  return ordinary<Int32>(offset);
400  }
401 
402  /// Identifies class or source of Tag 48-SecurityID value.
404  {
405  return SecurityIDSource();
406  }
407 
408  /// Security Type.
410  {
411  const BlockLength offset = 59;
412  const BlockLength length = 6;
413 
414  return fixedStr<length>(offset);
415  }
416 
417  /// ISO standard instrument categorization code.
418  StrRef cfiCode() const
419  {
420  const BlockLength offset = 65;
421  const BlockLength length = 6;
422 
423  return fixedStr<length>(offset);
424  }
425 
426  /// Identifies the currency used for price.
427  StrRef currency() const
428  {
429  const BlockLength offset = 71;
430  const BlockLength length = 3;
431 
432  return fixedStr<length>(offset);
433  }
434 
435  /// Identifies currency used for settlement, if different from
436  /// trade price currency.
438  {
439  const BlockLength offset = 74;
440  const BlockLength length = 3;
441 
442  return fixedStr<length>(offset);
443  }
444 
445  /// Matching Algorithm.
447  {
448  const BlockLength offset = 77;
449 
450  return ordinary<CHAR>(offset);
451  }
452 
453  /// The minimum trading volume for a security.
455  {
456  const BlockLength offset = 78;
457 
458  return ordinary<UInt32>(offset);
459  }
460 
461  /// The maximum trading volume for a security.
463  {
464  const BlockLength offset = 82;
465 
466  return ordinary<UInt32>(offset);
467  }
468 
469  /// Minimum constant tick for the instrument, sent only if
470  /// instrument is non-VTT (Variable Tick table) eligible.
472  {
473  typedef NullPRICE9 Null;
474 
475  const BlockLength offset = 86;
476 
477  return decimal(value, offset, Null());
478  }
479 
480  /// Contains the multiplier to convert the CME Globex display
481  /// price to the conventional price.
483  {
484  const BlockLength offset = 94;
485 
486  return decimal<Decimal9>(offset);
487  }
488 
489  /// Price Denominator of Main Fraction.
490  bool mainFraction(UInt8& value) const
491  {
492  typedef NullUInt8 Null;
493 
494  const BlockLength offset = 102;
495 
496  return ordinary(value, offset, Null());
497  }
498 
499  /// Price Denominator of Sub Fraction.
500  bool subFraction(UInt8& value) const
501  {
502  typedef NullUInt8 Null;
503 
504  const BlockLength offset = 103;
505 
506  return ordinary(value, offset, Null());
507  }
508 
509  /// Number of Decimals in Displayed Price.
511  {
512  typedef NullUInt8 Null;
513 
514  const BlockLength offset = 104;
515 
516  return ordinary(value, offset, Null());
517  }
518 
519  /// Unit of measure for the products' original contract size.
520  /// This will be populated for all products listed on CME
521  /// Globex.
523  {
524  const BlockLength offset = 105;
525  const BlockLength length = 30;
526 
527  return fixedStr<length>(offset);
528  }
529 
530  /// This field contains the contract size for each instrument.
531  /// Use in combination with tag 996-UnitofMeasure.
533  {
534  typedef NullDecimal9 Null;
535 
536  const BlockLength offset = 135;
537 
538  return decimal(value, offset, Null());
539  }
540 
541  /// Trading Reference Price.
543  {
544  typedef NullPRICE9 Null;
545 
546  const BlockLength offset = 143;
547 
548  return decimal(value, offset, Null());
549  }
550 
551  /// Indicates session date corresponding to the reference
552  /// price in tag 1150-TradingReferencePrice.
554  {
555  typedef NullLocalMktDate Null;
556  typedef LocalMktDate FieldValue;
557 
558  const BlockLength offset = 151;
559 
560  FieldValue fieldValue;
561 
562  if (ordinary(fieldValue, offset, Null()))
563  {
564  value = localMktDateToTimestamp(fieldValue);
565  return true;
566  }
567  return false;
568  }
569 
570  /// Allowable high limit price for the trading day.
572  {
573  typedef NullPRICE9 Null;
574 
575  const BlockLength offset = 153;
576 
577  return decimal(value, offset, Null());
578  }
579 
580  /// Allowable low limit price for the trading day.
582  {
583  typedef NullPRICE9 Null;
584 
585  const BlockLength offset = 161;
586 
587  return decimal(value, offset, Null());
588  }
589 
590  /// Differential value for price banding.
592  {
593  typedef NullPRICE9 Null;
594 
595  const BlockLength offset = 169;
596 
597  return decimal(value, offset, Null());
598  }
599 
600  /// Monetary value equivalent to the minimum price
601  /// fluctuation.
603  {
604  typedef NullPRICE9 Null;
605 
606  const BlockLength offset = 177;
607 
608  return decimal(value, offset, Null());
609  }
610 
611  /// Issue Date.
612  bool issueDate(Timestamp& value) const
613  {
614  typedef NullLocalMktDate Null;
615  typedef LocalMktDate FieldValue;
616 
617  const BlockLength offset = 185;
618 
619  FieldValue fieldValue;
620 
621  if (ordinary(fieldValue, offset, Null()))
622  {
623  value = localMktDateToTimestamp(fieldValue);
624  return true;
625  }
626  return false;
627  }
628 
629  /// Dated Date.
630  bool datedDate(Timestamp& value) const
631  {
632  typedef NullLocalMktDate Null;
633  typedef LocalMktDate FieldValue;
634 
635  const BlockLength offset = 187;
636 
637  FieldValue fieldValue;
638 
639  if (ordinary(fieldValue, offset, Null()))
640  {
641  value = localMktDateToTimestamp(fieldValue);
642  return true;
643  }
644  return false;
645  }
646 
647  /// Maturity Date.
649  {
650  typedef NullLocalMktDate Null;
651  typedef LocalMktDate FieldValue;
652 
653  const BlockLength offset = 189;
654 
655  FieldValue fieldValue;
656 
657  if (ordinary(fieldValue, offset, Null()))
658  {
659  value = localMktDateToTimestamp(fieldValue);
660  return true;
661  }
662  return false;
663  }
664 
665  /// The rate of interest that, when multiplied by the
666  /// principal, par value, or face value of a bond, provides
667  /// the currency amount of the periodic interest payment.
668  bool couponRate(Decimal& value) const
669  {
670  typedef NullDecimal9 Null;
671 
672  const BlockLength offset = 191;
673 
674  return decimal(value, offset, Null());
675  }
676 
677  /// Par value.
678  bool parValue(Decimal& value) const
679  {
680  typedef NullPRICE9 Null;
681 
682  const BlockLength offset = 199;
683 
684  return decimal(value, offset, Null());
685  }
686 
687  /// Time unit associated with the frequency of the bond's
688  /// coupon payment.
690  {
691  const BlockLength offset = 207;
692  const BlockLength length = 3;
693  const SchemaVersion since = 10;
694 
695  return fixedStr<length>(offset, since);
696  }
697 
698  /// Time unit multiplier for the frequency of the bond's
699  /// coupon payment.
701  {
702  typedef NullUInt16 Null;
703 
704  const BlockLength offset = 210;
705 
706  return ordinary(value, offset, Null());
707  }
708 
709  /// The day count convention used in interest calculations for
710  /// a bond or an interest bearing security.
712  {
713  const BlockLength offset = 212;
714  const BlockLength length = 20;
715  const SchemaVersion since = 10;
716 
717  return fixedStr<length>(offset, since);
718  }
719 
720  /// Country of Origin, ISO alpha-2 country code.
722  {
723  const BlockLength offset = 232;
724  const BlockLength length = 2;
725  const SchemaVersion since = 10;
726 
727  return fixedStr<length>(offset, since);
728  }
729 
730  /// Name of security issuer or the Legal Entity Identifier
731  /// (LEI - the International ISO standard 17442).
732  StrRef issuer() const
733  {
734  const BlockLength offset = 234;
735  const BlockLength length = 25;
736  const SchemaVersion since = 10;
737 
738  return fixedStr<length>(offset, since);
739  }
740 
741  /// Long name of the instrument.
743  {
744  const BlockLength offset = 259;
745  const BlockLength length = 35;
746  const SchemaVersion since = 10;
747 
748  return fixedStr<length>(offset, since);
749  }
750 
751  /// Expanded instrument description. Will contain either ISIN
752  /// or CUSIP.
754  {
755  const BlockLength offset = 294;
756  const BlockLength length = 12;
757  const SchemaVersion since = 10;
758 
759  return fixedStr<length>(offset, since);
760  }
761 
762  /// Identifies class or source of the SecurityAltID (455)
763  /// value.
765  {
766  typedef NullUInt8 Null;
767 
768  const BlockLength offset = 306;
769  const SchemaVersion since = 10;
770 
771  return enumeration<SecurityAltIDSource>(value, offset, Null(), since);
772  }
773 
774  /// Price quotation method.
776  {
777  const BlockLength offset = 307;
778  const BlockLength length = 5;
779  const SchemaVersion since = 10;
780 
781  return fixedStr<length>(offset, since);
782  }
783 
784  /// Clearing organization.
786  {
787  const BlockLength offset = 312;
788  const BlockLength length = 5;
789  const SchemaVersion since = 10;
790 
791  return fixedStr<length>(offset, since);
792  }
793 
794  /// User-defined Instrument flag.
796  {
797  const BlockLength offset = 317;
798 
799  return ordinary<UserDefinedInstrument>(offset);
800  }
801 
802  /// Risk Set identifies the list of instruments sharing credit
803  /// limits set up.
804  StrRef riskSet() const
805  {
806  const BlockLength offset = 318;
807  const BlockLength length = 6;
808  const SchemaVersion since = 10;
809 
810  return fixedStr<length>(offset, since);
811  }
812 
813  /// Market Set defines the bilateral relationship and Self
814  /// Match Prevention configuration for eligible markets.
816  {
817  const BlockLength offset = 324;
818  const BlockLength length = 6;
819  const SchemaVersion since = 10;
820 
821  return fixedStr<length>(offset, since);
822  }
823 
824  /// External unique instrument ID.
826  {
827  typedef NullUInt64 Null;
828 
829  const BlockLength offset = 330;
830 
831  return ordinary(value, offset, Null());
832  }
833 
834  /// Returns instance of Events repeating group.
835  Events events() const
836  {
837  return groups().head<Events>();
838  }
839 
840  /// Returns instance of FeedTypes repeating group.
841  FeedTypes feedTypes() const
842  {
843  return groups().tail<Events>().head<FeedTypes>();
844  }
845 
846  /// Returns instance of InstAttrib repeating group.
847  InstAttrib instAttrib() const
848  {
849  return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
850  }
851 
852  /// Returns instance of LotTypeRules repeating group.
853  LotTypeRules lotTypeRules() const
854  {
855  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
856  }
857 
858  /// Size of message body in bytes.
861  {
862  if (version >= 10)
863  return 338;
864 
865  return 207;
866  }
867 
868  /// Returns class name.
870  static const Char* className()
871  {
872  return "InstrumentDefinitionFixedIncome57";
873  }
874 
875  /// FIX message type.
877  static StrRef fixType()
878  {
879  return toStrRef("d");
880  }
881 };
882 
883 /// ChannelReset.
885 {
886  /// Message template ID from SBE schema.
887  enum
888  {
889  TemplateId = 4
890  };
891 
892  /// Number of entries in Market Data message.
893  /// Entry of Entry repeating group.
894  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
895  {
896  /// Aliases base class type.
898 
899  /// Initializes blank instance.
900  Entry() {}
901 
902  /// Initializes instance of given
903  /// version over given memory block.
904  Entry(const void* data, EncodedLength length, SchemaVersion version)
905  : Base(data, length, version)
906  {
907  if (length < blockLength(version))
908  throwBadBinaryData(className());
909  }
910 
911  /// Market Data update action.
913  {
914  return UpdateTypeNew();
915  }
916 
917  /// Market Data entry type.
919  {
920  return EntryTypeChannelReset();
921  }
922 
923  /// Indicates the channel ID as defined in the XML
924  /// configuration file.
925  Int16 applId() const
926  {
927  const BlockLength offset = 0;
928 
929  return ordinary<Int16>(offset);
930  }
931 
932  /// Returns size of entry body in bytes
933  /// for given version of message template.
936  {
937  return 2;
938  }
939 
940  /// Entity class name.
942  static const Char* className()
943  {
944  return "ChannelReset4.Entry";
945  }
946  };
947 
948  /// Repeating group containing Entry entries.
950 
951  /// Initializes blank instance.
953 
954  /// Initializes instance over given memory block.
955  ChannelReset4(const void* data, EncodedLength length)
956  : BinaryMessage(data, length)
957  {
958  assert(TemplateId == templateId());
959 
960  const SchemaVersion current = version();
962 
963  if (current < since)
964  throwBadMessageVersion(className(), current, since);
965 
966  if (length < blockLength(version()))
967  throwBadBinaryData(className());
968  }
969 
970  /// Start of event processing time in number of nanoseconds
971  /// since Unix epoch.
973  {
974  const BlockLength offset = 0;
975 
976  return ordinary<Timestamp>(offset);
977  }
978 
979  /// Bitmap field of eight Boolean type indicators reflecting
980  /// the end of updates for a given Globex event.
982  {
983  const BlockLength offset = 8;
984 
985  return ordinary<MatchEventIndicator>(offset);
986  }
987 
988  /// Returns instance of Entries repeating group.
989  Entries entries() const
990  {
991  return groups().head<Entries>();
992  }
993 
994  /// Size of message body in bytes.
997  {
998  return 9;
999  }
1000 
1001  /// Returns class name.
1003  static const Char* className()
1004  {
1005  return "ChannelReset4";
1006  }
1007 
1008  /// FIX message type.
1010  static StrRef fixType()
1011  {
1012  return toStrRef("X");
1013  }
1014 };
1015 
1016 /// AdminHeartbeat.
1018 {
1019  /// Message template ID from SBE schema.
1020  enum
1021  {
1022  TemplateId = 12
1023  };
1024 
1025  /// Initializes blank instance.
1027 
1028  /// Initializes instance over given memory block.
1029  AdminHeartbeat12(const void* data, EncodedLength length)
1030  : BinaryMessage(data, length)
1031  {
1032  assert(TemplateId == templateId());
1033 
1034  const SchemaVersion current = version();
1036 
1037  if (current < since)
1038  throwBadMessageVersion(className(), current, since);
1039 
1040  if (length < blockLength(version()))
1041  throwBadBinaryData(className());
1042  }
1043 
1044  /// Size of message body in bytes.
1047  {
1048  return 0;
1049  }
1050 
1051  /// Returns class name.
1053  static const Char* className()
1054  {
1055  return "AdminHeartbeat12";
1056  }
1057 
1058  /// FIX message type.
1060  static StrRef fixType()
1061  {
1062  return toStrRef("0");
1063  }
1064 };
1065 
1066 /// AdminLogin.
1068 {
1069  /// Message template ID from SBE schema.
1070  enum
1071  {
1072  TemplateId = 15
1073  };
1074 
1075  /// Initializes blank instance.
1077 
1078  /// Initializes instance over given memory block.
1079  AdminLogin15(const void* data, EncodedLength length)
1080  : BinaryMessage(data, length)
1081  {
1082  assert(TemplateId == templateId());
1083 
1084  const SchemaVersion current = version();
1086 
1087  if (current < since)
1088  throwBadMessageVersion(className(), current, since);
1089 
1090  if (length < blockLength(version()))
1091  throwBadBinaryData(className());
1092  }
1093 
1094  /// Heartbeat interval (seconds).
1096  {
1097  const BlockLength offset = 0;
1098 
1099  return ordinary<Int8>(offset);
1100  }
1101 
1102  /// Size of message body in bytes.
1105  {
1106  return 1;
1107  }
1108 
1109  /// Returns class name.
1111  static const Char* className()
1112  {
1113  return "AdminLogin15";
1114  }
1115 
1116  /// FIX message type.
1118  static StrRef fixType()
1119  {
1120  return toStrRef("A");
1121  }
1122 };
1123 
1124 /// AdminLogout.
1126 {
1127  /// Message template ID from SBE schema.
1128  enum
1129  {
1130  TemplateId = 16
1131  };
1132 
1133  /// Initializes blank instance.
1135 
1136  /// Initializes instance over given memory block.
1137  AdminLogout16(const void* data, EncodedLength length)
1138  : BinaryMessage(data, length)
1139  {
1140  assert(TemplateId == templateId());
1141 
1142  const SchemaVersion current = version();
1144 
1145  if (current < since)
1146  throwBadMessageVersion(className(), current, since);
1147 
1148  if (length < blockLength(version()))
1149  throwBadBinaryData(className());
1150  }
1151 
1152  /// Free format text string. May include logout confirmation
1153  /// or reason for logout.
1154  StrRef text() const
1155  {
1156  const BlockLength offset = 0;
1157  const BlockLength length = 180;
1158 
1159  return fixedStr<length>(offset);
1160  }
1161 
1162  /// Size of message body in bytes.
1165  {
1166  return 180;
1167  }
1168 
1169  /// Returns class name.
1171  static const Char* className()
1172  {
1173  return "AdminLogout16";
1174  }
1175 
1176  /// FIX message type.
1178  static StrRef fixType()
1179  {
1180  return toStrRef("5");
1181  }
1182 };
1183 
1184 /// AdminLogin.
1186 {
1187  /// Message template ID from SBE schema.
1188  enum
1189  {
1190  TemplateId = 408
1191  };
1192 
1193  /// Initializes blank instance.
1195 
1196  /// Initializes instance over given memory block.
1197  AdminLogin408(const void* data, EncodedLength length)
1198  : BinaryMessage(data, length)
1199  {
1200  assert(TemplateId == templateId());
1201 
1202  const SchemaVersion current = version();
1203 
1205 
1206  if (current < since)
1207  throwBadMessageVersion(className(), current, since);
1208 
1209  if (length < blockLength(version()))
1210  throwBadBinaryData(className());
1211  }
1212 
1213  /// Heartbeat interval (seconds).
1215  {
1216  const BlockLength offset = 0;
1217 
1218  return ordinary<Int8>(offset);
1219  }
1220 
1221  /// Size of message body in bytes.
1224  {
1225  return 1;
1226  }
1227 
1228  /// Returns class name.
1230  static const Char* className()
1231  {
1232  return "AdminLogin408";
1233  }
1234 
1235  /// FIX message type.
1237  static StrRef fixType()
1238  {
1239  return toStrRef("A");
1240  }
1241 };
1242 
1243 /// AdminLogout.
1245 {
1246  /// Message template ID from SBE schema.
1247  enum
1248  {
1249  TemplateId = 409
1250  };
1251 
1252  /// Initializes blank instance.
1254 
1255  /// Initializes instance over given memory block.
1256  AdminLogout409(const void* data, EncodedLength length)
1257  : BinaryMessage(data, length)
1258  {
1259  assert(TemplateId == templateId());
1260 
1261  const SchemaVersion current = version();
1262 
1264 
1265  if (current < since)
1266  throwBadMessageVersion(className(), current, since);
1267 
1268  if (length < blockLength(version()))
1269  throwBadBinaryData(className());
1270  }
1271 
1272  /// Free format text string. May include logout confirmation
1273  /// or reason for logout.
1274  StrRef text() const
1275  {
1276  const BlockLength offset = 0;
1277  const BlockLength length = 180;
1278 
1279  return fixedStr<length>(offset);
1280  }
1281 
1282  /// Size of message body in bytes.
1285  {
1286  return 180;
1287  }
1288 
1289  /// Returns class name.
1291  static const Char* className()
1292  {
1293  return "AdminLogout409";
1294  }
1295 
1296  /// FIX message type.
1298  static StrRef fixType()
1299  {
1300  return toStrRef("5");
1301  }
1302 };
1303 
1304 /// AdminHeartbeat.
1306 {
1307  /// Message template ID from SBE schema.
1308  enum
1309  {
1310  TemplateId = 410
1311  };
1312 
1313  /// Initializes blank instance.
1315 
1316  /// Initializes instance over given memory block.
1317  AdminHeartbeat410(const void* data, EncodedLength length)
1318  : BinaryMessage(data, length)
1319  {
1320  assert(TemplateId == templateId());
1321 
1322  const SchemaVersion current = version();
1323 
1325 
1326  if (current < since)
1327  throwBadMessageVersion(className(), current, since);
1328 
1329  if (length < blockLength(version()))
1330  throwBadBinaryData(className());
1331  }
1332 
1333  /// Size of message body in bytes.
1336  {
1337  return 0;
1338  }
1339 
1340  /// Returns class name.
1342  static const Char* className()
1343  {
1344  return "AdminHeartbeat410";
1345  }
1346 
1347  /// FIX message type.
1349  static StrRef fixType()
1350  {
1351  return toStrRef("0");
1352  }
1353 };
1354 
1355 /// MDInstrumentDefinitionFuture.
1357 {
1358  /// Message template ID from SBE schema.
1359  enum
1360  {
1361  TemplateId = 54
1362  };
1363 
1364  /// Number of repeating EventType entries.
1365  /// Entry of EventsEntry repeating group.
1366  struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
1367  {
1368  /// Aliases base class type.
1370 
1371  /// Initializes blank instance.
1373 
1374  /// Initializes instance of given
1375  /// version over given memory block.
1376  EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
1377  : Base(data, length, version)
1378  {
1379  if (length < blockLength(version))
1380  throwBadBinaryData(className());
1381  }
1382 
1383  /// Code to represent the type of event.
1385  {
1386  const BlockLength offset = 0;
1387 
1388  return enumeration<EventType>(offset);
1389  }
1390 
1391  /// Date and Time of instument Activation or Expiration event
1392  /// sent as number of nanoseconds since Unix epoch.
1394  {
1395  const BlockLength offset = 1;
1396 
1397  return ordinary<Timestamp>(offset);
1398  }
1399 
1400  /// Returns size of entry body in bytes
1401  /// for given version of message template.
1404  {
1405  return 9;
1406  }
1407 
1408  /// Entity class name.
1410  static const Char* className()
1411  {
1412  return "InstrumentDefinitionFuture54.EventsEntry";
1413  }
1414  };
1415 
1416  /// Repeating group containing EventsEntry entries.
1418 
1419  /// Number of repeating FeedType entries.
1420  /// Entry of FeedTypesEntry repeating group.
1421  struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
1422  {
1423  /// Aliases base class type.
1425 
1426  /// Initializes blank instance.
1428 
1429  /// Initializes instance of given
1430  /// version over given memory block.
1431  FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
1432  : Base(data, length, version)
1433  {
1434  if (length < blockLength(version))
1435  throwBadBinaryData(className());
1436  }
1437 
1438  /// Describes a class of service for a given data feed. GBX-
1439  /// Real Book, GBI-Implied Book.
1441  {
1442  const BlockLength offset = 0;
1443  const BlockLength length = 3;
1444 
1445  return fixedStr<length>(offset);
1446  }
1447 
1448  /// Book depth.
1450  {
1451  const BlockLength offset = 3;
1452 
1453  return ordinary<Int8>(offset);
1454  }
1455 
1456  /// Returns size of entry body in bytes
1457  /// for given version of message template.
1460  {
1461  return 4;
1462  }
1463 
1464  /// Entity class name.
1466  static const Char* className()
1467  {
1468  return "InstrumentDefinitionFuture54.FeedTypesEntry";
1469  }
1470  };
1471 
1472  /// Repeating group containing FeedTypesEntry entries.
1474 
1475  /// Number of repeating InstrAttribType entries.
1476  /// Entry of InstAttribEntry repeating group.
1477  struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
1478  {
1479  /// Aliases base class type.
1481 
1482  /// Initializes blank instance.
1484 
1485  /// Initializes instance of given
1486  /// version over given memory block.
1487  InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
1488  : Base(data, length, version)
1489  {
1490  if (length < blockLength(version))
1491  throwBadBinaryData(className());
1492  }
1493 
1494  /// Instrument eligibility attributes.
1496  {
1497  return InstAttribType();
1498  }
1499 
1500  /// Bitmap field of 32 Boolean type instrument eligibility
1501  /// flags.
1503  {
1504  const BlockLength offset = 0;
1505 
1506  return ordinary<InstAttribValue>(offset);
1507  }
1508 
1509  /// Returns size of entry body in bytes
1510  /// for given version of message template.
1513  {
1514  return 4;
1515  }
1516 
1517  /// Entity class name.
1519  static const Char* className()
1520  {
1521  return "InstrumentDefinitionFuture54.InstAttribEntry";
1522  }
1523  };
1524 
1525  /// Repeating group containing InstAttribEntry entries.
1527 
1528  /// Number of entries.
1529  /// Entry of LotTypeRulesEntry repeating group.
1530  struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
1531  {
1532  /// Aliases base class type.
1534 
1535  /// Initializes blank instance.
1537 
1538  /// Initializes instance of given
1539  /// version over given memory block.
1540  LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
1541  : Base(data, length, version)
1542  {
1543  if (length < blockLength(version))
1544  throwBadBinaryData(className());
1545  }
1546 
1547  /// This tag is required to interpret the value in tag
1548  /// 1231-MinLotSize.
1549  Int8 lotType() const
1550  {
1551  const BlockLength offset = 0;
1552 
1553  return ordinary<Int8>(offset);
1554  }
1555 
1556  /// Minimum quantity accepted for order entry. If tag
1557  /// 1093-LotType=4, this value is the minimum quantity for
1558  /// order entry expressed in the applicable units, specified
1559  /// in tag 996-UnitOfMeasure, e.g. megawatts.
1560  bool minLotSize(Decimal& value) const
1561  {
1562  typedef NullDecimalQty Null;
1563 
1564  const BlockLength offset = 1;
1565 
1566  return decimal(value, offset, Null());
1567  }
1568 
1569  /// Returns size of entry body in bytes
1570  /// for given version of message template.
1573  {
1574  return 5;
1575  }
1576 
1577  /// Entity class name.
1579  static const Char* className()
1580  {
1581  return "InstrumentDefinitionFuture54.LotTypeRulesEntry";
1582  }
1583  };
1584 
1585  /// Repeating group containing LotTypeRulesEntry entries.
1587 
1588  /// Initializes blank instance.
1590 
1591  /// Initializes instance over given memory block.
1593  : BinaryMessage(data, length)
1594  {
1595  assert(TemplateId == templateId());
1596 
1597  const SchemaVersion current = version();
1599 
1600  if (current < since)
1601  throwBadMessageVersion(className(), current, since);
1602 
1603  if (length < blockLength(version()))
1604  throwBadBinaryData(className());
1605  }
1606 
1607  /// Bitmap field of eight Boolean type indicators reflecting
1608  /// the end of updates for a given Globex event.
1610  {
1611  const BlockLength offset = 0;
1612 
1613  return ordinary<MatchEventIndicator>(offset);
1614  }
1615 
1616  /// Total number of instruments in the Replay loop. Used on
1617  /// Replay Feed only.
1619  {
1620  typedef NullUInt32 Null;
1621 
1622  const BlockLength offset = 1;
1623 
1624  return ordinary(value, offset, Null());
1625  }
1626 
1627  /// Last Security update action on Incremental feed, 'D' or
1628  /// 'M' is used when a mid-week deletion or modification (i.e.
1629  /// extension) occurs.
1631  {
1632  const BlockLength offset = 5;
1633 
1634  return enumeration<SecurityUpdateAction>(offset);
1635  }
1636 
1637  /// Timestamp of when the instrument was last added, modified
1638  /// or deleted.
1640  {
1641  const BlockLength offset = 6;
1642 
1643  return ordinary<Timestamp>(offset);
1644  }
1645 
1646  /// Identifies the current state of the instrument. In
1647  /// Security Definition message this tag is available in the
1648  /// Instrument Replay feed only.
1650  {
1651  typedef NullUInt8 Null;
1652 
1653  const BlockLength offset = 14;
1654 
1655  return enumeration<SecurityTradingStatus>(value, offset, Null());
1656  }
1657 
1658  /// The channel ID as defined in the XML Configuration file.
1659  Int16 applId() const
1660  {
1661  const BlockLength offset = 15;
1662 
1663  return ordinary<Int16>(offset);
1664  }
1665 
1666  /// Identifies the market segment, populated for all CME
1667  /// Globex instruments.
1669  {
1670  const BlockLength offset = 17;
1671 
1672  return ordinary<UInt8>(offset);
1673  }
1674 
1675  /// Product complex.
1677  {
1678  const BlockLength offset = 18;
1679 
1680  return ordinary<UInt8>(offset);
1681  }
1682 
1683  /// Exchange used to identify a security.
1685  {
1686  const BlockLength offset = 19;
1687  const BlockLength length = 4;
1688 
1689  return fixedStr<length>(offset);
1690  }
1691 
1692  /// Security Group Code.
1694  {
1695  const BlockLength offset = 23;
1696  const BlockLength length = 6;
1697 
1698  return fixedStr<length>(offset);
1699  }
1700 
1701  /// The underlying asset code also known as Product Code.
1702  StrRef asset() const
1703  {
1704  const BlockLength offset = 29;
1705  const BlockLength length = 6;
1706 
1707  return fixedStr<length>(offset);
1708  }
1709 
1710  /// Instrument Name or Symbol.
1711  StrRef symbol() const
1712  {
1713  const BlockLength offset = 35;
1714  const BlockLength length = 20;
1715 
1716  return fixedStr<length>(offset);
1717  }
1718 
1719  /// Unique instrument ID.
1721  {
1722  const BlockLength offset = 55;
1723 
1724  return ordinary<Int32>(offset);
1725  }
1726 
1727  /// Identifies class or source of tag 48-SecurityID value.
1729  {
1730  return SecurityIDSource();
1731  }
1732 
1733  /// Security Type.
1735  {
1736  const BlockLength offset = 59;
1737  const BlockLength length = 6;
1738 
1739  return fixedStr<length>(offset);
1740  }
1741 
1742  /// ISO standard instrument categorization code.
1743  StrRef cfiCode() const
1744  {
1745  const BlockLength offset = 65;
1746  const BlockLength length = 6;
1747 
1748  return fixedStr<length>(offset);
1749  }
1750 
1751  /// This field provides the actual calendar date for contract
1752  /// maturity.
1754  {
1755  typedef NullMaturityMonthYear Null;
1756 
1757  const BlockLength offset = 71;
1758 
1759  return ordinary(value, offset, Null());
1760  }
1761 
1762  /// Identifies currency used for price.
1764  {
1765  const BlockLength offset = 76;
1766  const BlockLength length = 3;
1767 
1768  return fixedStr<length>(offset);
1769  }
1770 
1771  /// Identifies currency used for settlement, if different from
1772  /// trading currency.
1774  {
1775  const BlockLength offset = 79;
1776  const BlockLength length = 3;
1777 
1778  return fixedStr<length>(offset);
1779  }
1780 
1781  /// Matching algorithm.
1783  {
1784  const BlockLength offset = 82;
1785 
1786  return ordinary<CHAR>(offset);
1787  }
1788 
1789  /// The minimum trading volume for a security.
1791  {
1792  const BlockLength offset = 83;
1793 
1794  return ordinary<UInt32>(offset);
1795  }
1796 
1797  /// The maximum trading volume for a security.
1799  {
1800  const BlockLength offset = 87;
1801 
1802  return ordinary<UInt32>(offset);
1803  }
1804 
1805  /// Minimum constant tick for the instrument, sent only if
1806  /// instrument is non-VTT (Variable Tick table) eligible.
1808  {
1809  const BlockLength offset = 91;
1810 
1811  return decimal<PRICE9>(offset);
1812  }
1813 
1814  /// Contains the multiplier to convert the CME Globex display
1815  /// price to the conventional price.
1817  {
1818  const BlockLength offset = 99;
1819 
1820  return decimal<Decimal9>(offset);
1821  }
1822 
1823  /// Price Denominator of Main Fraction.
1824  bool mainFraction(UInt8& value) const
1825  {
1826  typedef NullUInt8 Null;
1827 
1828  const BlockLength offset = 107;
1829 
1830  return ordinary(value, offset, Null());
1831  }
1832 
1833  /// Price Denominator of Sub Fraction.
1834  bool subFraction(UInt8& value) const
1835  {
1836  typedef NullUInt8 Null;
1837 
1838  const BlockLength offset = 108;
1839 
1840  return ordinary(value, offset, Null());
1841  }
1842 
1843  /// Number of decimals in fractional display price.
1845  {
1846  typedef NullUInt8 Null;
1847 
1848  const BlockLength offset = 109;
1849 
1850  return ordinary(value, offset, Null());
1851  }
1852 
1853  /// Unit of measure for the products' original contract size.
1854  /// This will be populated for all products listed on CME
1855  /// Globex.
1857  {
1858  const BlockLength offset = 110;
1859  const BlockLength length = 30;
1860 
1861  return fixedStr<length>(offset);
1862  }
1863 
1864  /// This field contains the contract size for each instrument.
1865  /// Used in combination with tag 996-UnitofMeasure.
1867  {
1868  typedef NullDecimal9 Null;
1869 
1870  const BlockLength offset = 140;
1871 
1872  return decimal(value, offset, Null());
1873  }
1874 
1875  /// Reference price for prelisted instruments or the last
1876  /// calculated Settlement whether it be Theoretical,
1877  /// Preliminary or a Final Settle of the session.
1879  {
1880  typedef NullPRICE9 Null;
1881 
1882  const BlockLength offset = 148;
1883 
1884  return decimal(value, offset, Null());
1885  }
1886 
1887  /// Bitmap field of eight Boolean type indicators representing
1888  /// settlement price type.
1890  {
1891  const BlockLength offset = 156;
1892 
1893  return ordinary<SettlPriceType>(offset);
1894  }
1895 
1896  /// The total open interest for the market at the close of the
1897  /// prior trading session.
1899  {
1900  typedef NullInt32 Null;
1901 
1902  const BlockLength offset = 157;
1903 
1904  return ordinary(value, offset, Null());
1905  }
1906 
1907  /// The total cleared volume of instrument traded during the
1908  /// prior trading session.
1910  {
1911  typedef NullInt32 Null;
1912 
1913  const BlockLength offset = 161;
1914 
1915  return ordinary(value, offset, Null());
1916  }
1917 
1918  /// Allowable high limit price for the trading day.
1920  {
1921  typedef NullPRICE9 Null;
1922 
1923  const BlockLength offset = 165;
1924 
1925  return decimal(value, offset, Null());
1926  }
1927 
1928  /// Allowable low limit price for the trading day.
1930  {
1931  typedef NullPRICE9 Null;
1932 
1933  const BlockLength offset = 173;
1934 
1935  return decimal(value, offset, Null());
1936  }
1937 
1938  /// Differential value for price banding.
1940  {
1941  typedef NullPRICE9 Null;
1942 
1943  const BlockLength offset = 181;
1944 
1945  return decimal(value, offset, Null());
1946  }
1947 
1948  /// Indicates the quantity that a contract will decay daily by
1949  /// once the decay start date is reached.
1951  {
1952  typedef NullInt32 Null;
1953 
1954  const BlockLength offset = 189;
1955 
1956  return ordinary(value, offset, Null());
1957  }
1958 
1959  /// Indicates the date at which a decaying contract will begin
1960  /// to decay.
1962  {
1963  typedef NullLocalMktDate Null;
1964  typedef LocalMktDate FieldValue;
1965 
1966  const BlockLength offset = 193;
1967 
1968  FieldValue fieldValue;
1969 
1970  if (ordinary(fieldValue, offset, Null()))
1971  {
1972  value = localMktDateToTimestamp(fieldValue);
1973  return true;
1974  }
1975  return false;
1976  }
1977 
1978  /// Fixed contract value assigned to each product.
1980  {
1981  typedef NullInt32 Null;
1982 
1983  const BlockLength offset = 195;
1984 
1985  return ordinary(value, offset, Null());
1986  }
1987 
1988  /// Number of deliverable units per instrument, e.g., peak
1989  /// days in maturity month or number of calendar days in
1990  /// maturity month.
1992  {
1993  typedef NullInt32 Null;
1994 
1995  const BlockLength offset = 199;
1996 
1997  return ordinary(value, offset, Null());
1998  }
1999 
2000  /// Indicates the type of multiplier being applied to the
2001  /// product. Optionally used in combination with tag
2002  /// 231-ContractMultiplier.
2004  {
2005  typedef NullInt8 Null;
2006 
2007  const BlockLength offset = 203;
2008 
2009  return ordinary(value, offset, Null());
2010  }
2011 
2012  /// The schedule according to which the electricity is
2013  /// delivered in a physical contract, or priced in a financial
2014  /// contract. Specifies whether the contract is defined
2015  /// according to the Easter Peak, Eastern Off-Peak, Western
2016  /// Peak or Western Off-Peak.
2018  {
2019  typedef NullInt8 Null;
2020 
2021  const BlockLength offset = 204;
2022 
2023  return ordinary(value, offset, Null());
2024  }
2025 
2026  /// Monetary value equivalent to the minimum price fluctuation.
2028  {
2029  typedef NullPRICE9 Null;
2030 
2031  const BlockLength offset = 205;
2032 
2033  return decimal(value, offset, Null());
2034  }
2035 
2036  /// User-defined instruments flag.
2038  {
2039  const BlockLength offset = 213;
2040 
2041  return ordinary<UserDefinedInstrument>(offset);
2042  }
2043 
2044  /// Indicates session date corresponding to the settlement
2045  /// price in tag 1150-TradingReferencePrice.
2047  {
2048  typedef NullLocalMktDate Null;
2049  typedef LocalMktDate FieldValue;
2050 
2051  const BlockLength offset = 214;
2052 
2053  FieldValue fieldValue;
2054 
2055  if (ordinary(fieldValue, offset, Null()))
2056  {
2057  value = localMktDateToTimestamp(fieldValue);
2058  return true;
2059  }
2060  return false;
2061  }
2062 
2063  /// External unique instrument ID.
2065  {
2066  typedef NullUInt64 Null;
2067 
2068  const BlockLength offset = 216;
2069  const SchemaVersion since = 10;
2070 
2071  return ordinary(value, offset, Null(), since);
2072  }
2073 
2074  /// Returns instance of Events repeating group.
2075  Events events() const
2076  {
2077  return groups().head<Events>();
2078  }
2079 
2080  /// Returns instance of FeedTypes repeating group.
2081  FeedTypes feedTypes() const
2082  {
2083  return groups().tail<Events>().head<FeedTypes>();
2084  }
2085 
2086  /// Returns instance of InstAttrib repeating group.
2087  InstAttrib instAttrib() const
2088  {
2089  return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
2090  }
2091 
2092  /// Returns instance of LotTypeRules repeating group.
2093  LotTypeRules lotTypeRules() const
2094  {
2095  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
2096  }
2097 
2098  /// Size of message body in bytes.
2101  {
2102  if (version >= 10)
2103  return 224;
2104 
2105  return 216;
2106  }
2107 
2108  /// Returns class name.
2110  static const Char* className()
2111  {
2112  return "InstrumentDefinitionFuture54";
2113  }
2114 
2115  /// FIX message type.
2117  static StrRef fixType()
2118  {
2119  return toStrRef("d");
2120  }
2121 };
2122 
2123 /// MDInstrumentDefinitionSpread.
2125 {
2126  /// Message template ID from SBE schema.
2127  enum
2128  {
2129  TemplateId = 56
2130  };
2131 
2132  /// Number of repeating EventType entries.
2133  /// Entry of EventsEntry repeating group.
2134  struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
2135  {
2136  /// Aliases base class type.
2138 
2139  /// Initializes blank instance.
2141 
2142  /// Initializes instance of given
2143  /// version over given memory block.
2144  EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
2145  : Base(data, length, version)
2146  {
2147  if (length < blockLength(version))
2148  throwBadBinaryData(className());
2149  }
2150 
2151  /// Code to represent the type of event.
2153  {
2154  const BlockLength offset = 0;
2155 
2156  return enumeration<EventType>(offset);
2157  }
2158 
2159  /// Date and time of instument Activation or Expiration event
2160  /// sent as number of nanoseconds since Unix epoch.
2162  {
2163  const BlockLength offset = 1;
2164 
2165  return ordinary<Timestamp>(offset);
2166  }
2167 
2168  /// Returns size of entry body in bytes
2169  /// for given version of message template.
2172  {
2173  return 9;
2174  }
2175 
2176  /// Entity class name.
2178  static const Char* className()
2179  {
2180  return "InstrumentDefinitionSpread56.EventsEntry";
2181  }
2182  };
2183 
2184  /// Repeating group containing EventsEntry entries.
2186 
2187  /// Number of FeedType entries.
2188  /// Entry of FeedTypesEntry repeating group.
2189  struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
2190  {
2191  /// Aliases base class type.
2193 
2194  /// Initializes blank instance.
2196 
2197  /// Initializes instance of given
2198  /// version over given memory block.
2199  FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
2200  : Base(data, length, version)
2201  {
2202  if (length < blockLength(version))
2203  throwBadBinaryData(className());
2204  }
2205 
2206  /// Describes a class of service for a given data feed. GBX-
2207  /// Real Book, GBI-Implied Book.
2209  {
2210  const BlockLength offset = 0;
2211  const BlockLength length = 3;
2212 
2213  return fixedStr<length>(offset);
2214  }
2215 
2216  /// Identifies the depth of book.
2218  {
2219  const BlockLength offset = 3;
2220 
2221  return ordinary<Int8>(offset);
2222  }
2223 
2224  /// Returns size of entry body in bytes
2225  /// for given version of message template.
2228  {
2229  return 4;
2230  }
2231 
2232  /// Entity class name.
2234  static const Char* className()
2235  {
2236  return "InstrumentDefinitionSpread56.FeedTypesEntry";
2237  }
2238  };
2239 
2240  /// Repeating group containing FeedTypesEntry entries.
2242 
2243  /// Number of InstrAttribType entries.
2244  /// Entry of InstAttribEntry repeating group.
2245  struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
2246  {
2247  /// Aliases base class type.
2249 
2250  /// Initializes blank instance.
2252 
2253  /// Initializes instance of given
2254  /// version over given memory block.
2255  InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
2256  : Base(data, length, version)
2257  {
2258  if (length < blockLength(version))
2259  throwBadBinaryData(className());
2260  }
2261 
2262  /// Instrument Eligibility Attributes.
2264  {
2265  return InstAttribType();
2266  }
2267 
2268  /// Bitmap field of 32 Boolean type Instrument eligibility
2269  /// flags.
2271  {
2272  const BlockLength offset = 0;
2273 
2274  return ordinary<InstAttribValue>(offset);
2275  }
2276 
2277  /// Returns size of entry body in bytes
2278  /// for given version of message template.
2281  {
2282  return 4;
2283  }
2284 
2285  /// Entity class name.
2287  static const Char* className()
2288  {
2289  return "InstrumentDefinitionSpread56.InstAttribEntry";
2290  }
2291  };
2292 
2293  /// Repeating group containing InstAttribEntry entries.
2295 
2296  /// Number of entries.
2297  /// Entry of LotTypeRulesEntry repeating group.
2298  struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
2299  {
2300  /// Aliases base class type.
2302 
2303  /// Initializes blank instance.
2305 
2306  /// Initializes instance of given
2307  /// version over given memory block.
2308  LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
2309  : Base(data, length, version)
2310  {
2311  if (length < blockLength(version))
2312  throwBadBinaryData(className());
2313  }
2314 
2315  /// This tag is required to interpret the value in tag
2316  /// 1231-MinLotSize.
2317  Int8 lotType() const
2318  {
2319  const BlockLength offset = 0;
2320 
2321  return ordinary<Int8>(offset);
2322  }
2323 
2324  /// Minimum quantity accepted for order entry. If tag
2325  /// 1093-LotType=4, this value is the minimum quantity for
2326  /// order entry expressed in the applicable units, specified
2327  /// in tag 996-UnitOfMeasure, e.g. megawatts.
2328  bool minLotSize(Decimal& value) const
2329  {
2330  typedef NullDecimalQty Null;
2331 
2332  const BlockLength offset = 1;
2333 
2334  return decimal(value, offset, Null());
2335  }
2336 
2337  /// Returns size of entry body in bytes
2338  /// for given version of message template.
2341  {
2342  return 5;
2343  }
2344 
2345  /// Entity class name.
2347  static const Char* className()
2348  {
2349  return "InstrumentDefinitionSpread56.LotTypeRulesEntry";
2350  }
2351  };
2352 
2353  /// Repeating group containing LotTypeRulesEntry entries.
2355 
2356  /// Number of Leg entries.
2357  /// Entry of LegsEntry repeating group.
2358  struct ONIXS_CMEMDH_LTWT LegsEntry : BinaryGroupEntry<GroupSize::BlockLength>
2359  {
2360  /// Aliases base class type.
2362 
2363  /// Initializes blank instance.
2365 
2366  /// Initializes instance of given
2367  /// version over given memory block.
2368  LegsEntry(const void* data, EncodedLength length, SchemaVersion version)
2369  : Base(data, length, version)
2370  {
2371  if (length < blockLength(version))
2372  throwBadBinaryData(className());
2373  }
2374 
2375  /// Leg Security ID.
2377  {
2378  const BlockLength offset = 0;
2379 
2380  return ordinary<Int32>(offset);
2381  }
2382 
2383  /// Identifies source of tag 602-LegSecurityID value.
2385  {
2386  return SecurityIDSource();
2387  }
2388 
2389  /// Leg side.
2391  {
2392  const BlockLength offset = 4;
2393 
2394  return enumeration<LegSide>(offset);
2395  }
2396 
2397  /// Leg ratio of quantity for this individual leg relative to
2398  /// the entire multi-leg instrument.
2400  {
2401  const BlockLength offset = 5;
2402 
2403  return ordinary<Int8>(offset);
2404  }
2405 
2406  /// Price for the future leg of a UDS Covered instrument.
2407  bool legPrice(Decimal& value) const
2408  {
2409  typedef NullPRICE9 Null;
2410 
2411  const BlockLength offset = 6;
2412 
2413  return decimal(value, offset, Null());
2414  }
2415 
2416  /// Delta used to calculate the quantity of futures used to
2417  /// cover the option or option strategy.
2419  {
2420  typedef NullDecimalQty Null;
2421 
2422  const BlockLength offset = 14;
2423 
2424  return decimal(value, offset, Null());
2425  }
2426 
2427  /// Returns size of entry body in bytes
2428  /// for given version of message template.
2431  {
2432  return 18;
2433  }
2434 
2435  /// Entity class name.
2437  static const Char* className()
2438  {
2439  return "InstrumentDefinitionSpread56.LegsEntry";
2440  }
2441  };
2442 
2443  /// Repeating group containing LegsEntry entries.
2445 
2446  /// Initializes blank instance.
2448 
2449  /// Initializes instance over given memory block.
2451  : BinaryMessage(data, length)
2452  {
2453  assert(TemplateId == templateId());
2454 
2455  const SchemaVersion current = version();
2457 
2458  if (current < since)
2459  throwBadMessageVersion(className(), current, since);
2460 
2461  if (length < blockLength(version()))
2462  throwBadBinaryData(className());
2463  }
2464 
2465  /// Bitmap field of eight Boolean type indicators reflecting
2466  /// the end of updates for a given Globex event.
2468  {
2469  const BlockLength offset = 0;
2470 
2471  return ordinary<MatchEventIndicator>(offset);
2472  }
2473 
2474  /// Total number of instruments in the Replay loop. Used on
2475  /// Replay Feed only.
2477  {
2478  typedef NullUInt32 Null;
2479 
2480  const BlockLength offset = 1;
2481 
2482  return ordinary(value, offset, Null());
2483  }
2484 
2485  /// Last Security update action on Incremental feed, 'D' or
2486  /// 'M' is used when a mid-week deletion or modification (i.e.
2487  /// extension) occurs.
2489  {
2490  const BlockLength offset = 5;
2491 
2492  return enumeration<SecurityUpdateAction>(offset);
2493  }
2494 
2495  /// Timestamp of when the instrument was last added, modified
2496  /// or deleted.
2498  {
2499  const BlockLength offset = 6;
2500 
2501  return ordinary<Timestamp>(offset);
2502  }
2503 
2504  /// Identifies the current state of the instrument. The data
2505  /// is available in the Instrument Replay feed only.
2507  {
2508  typedef NullUInt8 Null;
2509 
2510  const BlockLength offset = 14;
2511 
2512  return enumeration<SecurityTradingStatus>(value, offset, Null());
2513  }
2514 
2515  /// The channel ID as defined in the XML Configuration file.
2516  Int16 applId() const
2517  {
2518  const BlockLength offset = 15;
2519 
2520  return ordinary<Int16>(offset);
2521  }
2522 
2523  /// Identifies the market segment, populated for all CME
2524  /// Globex instruments.
2526  {
2527  const BlockLength offset = 17;
2528 
2529  return ordinary<UInt8>(offset);
2530  }
2531 
2532  /// Product complex.
2534  {
2535  typedef NullUInt8 Null;
2536 
2537  const BlockLength offset = 18;
2538 
2539  return ordinary(value, offset, Null());
2540  }
2541 
2542  /// Exchange used to identify a security.
2544  {
2545  const BlockLength offset = 19;
2546  const BlockLength length = 4;
2547 
2548  return fixedStr<length>(offset);
2549  }
2550 
2551  /// Security Group Code.
2553  {
2554  const BlockLength offset = 23;
2555  const BlockLength length = 6;
2556 
2557  return fixedStr<length>(offset);
2558  }
2559 
2560  /// The underlying asset code also known as Product Code.
2561  StrRef asset() const
2562  {
2563  const BlockLength offset = 29;
2564  const BlockLength length = 6;
2565 
2566  return fixedStr<length>(offset);
2567  }
2568 
2569  /// Instrument Name or Symbol. Previously used as Group Code.
2570  StrRef symbol() const
2571  {
2572  const BlockLength offset = 35;
2573  const BlockLength length = 20;
2574 
2575  return fixedStr<length>(offset);
2576  }
2577 
2578  /// Unique instrument ID.
2580  {
2581  const BlockLength offset = 55;
2582 
2583  return ordinary<Int32>(offset);
2584  }
2585 
2586  /// Identifies class or source of the security ID (Tag 48)
2587  /// value.
2589  {
2590  return SecurityIDSource();
2591  }
2592 
2593  /// Security Type.
2595  {
2596  const BlockLength offset = 59;
2597  const BlockLength length = 6;
2598 
2599  return fixedStr<length>(offset);
2600  }
2601 
2602  /// ISO standard instrument categorization code.
2603  StrRef cfiCode() const
2604  {
2605  const BlockLength offset = 65;
2606  const BlockLength length = 6;
2607 
2608  return fixedStr<length>(offset);
2609  }
2610 
2611  /// This field provides the actual calendar date for contract
2612  /// maturity.
2614  {
2615  typedef NullMaturityMonthYear Null;
2616 
2617  const BlockLength offset = 71;
2618 
2619  return ordinary(value, offset, Null());
2620  }
2621 
2622  /// Identifies currency used for price.
2624  {
2625  const BlockLength offset = 76;
2626  const BlockLength length = 3;
2627 
2628  return fixedStr<length>(offset);
2629  }
2630 
2631  /// Strategy type.
2633  {
2634  const BlockLength offset = 79;
2635  const BlockLength length = 5;
2636 
2637  return fixedStr<length>(offset);
2638  }
2639 
2640  /// User-defined instruments flag.
2642  {
2643  const BlockLength offset = 84;
2644 
2645  return ordinary<UserDefinedInstrument>(offset);
2646  }
2647 
2648  /// Matching algorithm.
2650  {
2651  const BlockLength offset = 85;
2652 
2653  return ordinary<CHAR>(offset);
2654  }
2655 
2656  /// The minimum trading volume for a security.
2658  {
2659  const BlockLength offset = 86;
2660 
2661  return ordinary<UInt32>(offset);
2662  }
2663 
2664  /// The maximum trading volume for a security.
2666  {
2667  const BlockLength offset = 90;
2668 
2669  return ordinary<UInt32>(offset);
2670  }
2671 
2672  /// Minimum constant tick for the instrument, sent only if
2673  /// instrument is non-VTT (Variable Tick table) eligible.
2675  {
2676  typedef NullPRICE9 Null;
2677 
2678  const BlockLength offset = 94;
2679 
2680  return decimal(value, offset, Null());
2681  }
2682 
2683  /// Contains the multiplier to convert the CME Globex display
2684  /// price to the conventional price.
2686  {
2687  const BlockLength offset = 102;
2688 
2689  return decimal<Decimal9>(offset);
2690  }
2691 
2692  /// Number of decimals in fractional display price.
2694  {
2695  typedef NullUInt8 Null;
2696 
2697  const BlockLength offset = 110;
2698 
2699  return ordinary(value, offset, Null());
2700  }
2701 
2702  /// Used for price calculation in spread and leg pricing.
2703  bool priceRatio(Decimal& value) const
2704  {
2705  typedef NullPRICE9 Null;
2706 
2707  const BlockLength offset = 111;
2708 
2709  return decimal(value, offset, Null());
2710  }
2711 
2712  /// Tick Rule.
2713  bool tickRule(Int8& value) const
2714  {
2715  typedef NullInt8 Null;
2716 
2717  const BlockLength offset = 119;
2718 
2719  return ordinary(value, offset, Null());
2720  }
2721 
2722  /// Unit of measure for the products' original contract size.
2724  {
2725  const BlockLength offset = 120;
2726  const BlockLength length = 30;
2727 
2728  return fixedStr<length>(offset);
2729  }
2730 
2731  /// Reference price - the most recently available Settlement
2732  /// whether it be Theoretical, Preliminary or a Final Settle
2733  /// of the session.
2735  {
2736  typedef NullPRICE9 Null;
2737 
2738  const BlockLength offset = 150;
2739 
2740  return decimal(value, offset, Null());
2741  }
2742 
2743  /// Bitmap field of eight Boolean type indicators representing
2744  /// settlement price type.
2746  {
2747  const BlockLength offset = 158;
2748 
2749  return ordinary<SettlPriceType>(offset);
2750  }
2751 
2752  /// The total open interest for the market at the close of the
2753  /// prior trading session.
2755  {
2756  typedef NullInt32 Null;
2757 
2758  const BlockLength offset = 159;
2759 
2760  return ordinary(value, offset, Null());
2761  }
2762 
2763  /// The total cleared volume of instrument traded during the
2764  /// prior trading session.
2766  {
2767  typedef NullInt32 Null;
2768 
2769  const BlockLength offset = 163;
2770 
2771  return ordinary(value, offset, Null());
2772  }
2773 
2774  /// Allowable high limit price for the trading day.
2776  {
2777  typedef NullPRICE9 Null;
2778 
2779  const BlockLength offset = 167;
2780 
2781  return decimal(value, offset, Null());
2782  }
2783 
2784  /// Allowable low limit price for the trading day.
2786  {
2787  typedef NullPRICE9 Null;
2788 
2789  const BlockLength offset = 175;
2790 
2791  return decimal(value, offset, Null());
2792  }
2793 
2794  /// Differential value for price banding.
2796  {
2797  typedef NullPRICE9 Null;
2798 
2799  const BlockLength offset = 183;
2800 
2801  return decimal(value, offset, Null());
2802  }
2803 
2804  /// Price Denominator of Main Fraction.
2805  bool mainFraction(UInt8& value) const
2806  {
2807  typedef NullUInt8 Null;
2808 
2809  const BlockLength offset = 191;
2810 
2811  return ordinary(value, offset, Null());
2812  }
2813 
2814  /// Price Denominator of Sub Fraction.
2815  bool subFraction(UInt8& value) const
2816  {
2817  typedef NullUInt8 Null;
2818 
2819  const BlockLength offset = 192;
2820 
2821  return ordinary(value, offset, Null());
2822  }
2823 
2824  /// Indicates session date corresponding to the settlement
2825  /// price in tag 1150-TradingReferencePrice.
2827  {
2828  typedef NullLocalMktDate Null;
2829  typedef LocalMktDate FieldValue;
2830 
2831  const BlockLength offset = 193;
2832 
2833  FieldValue fieldValue;
2834 
2835  if (ordinary(fieldValue, offset, Null()))
2836  {
2837  value = localMktDateToTimestamp(fieldValue);
2838  return true;
2839  }
2840  return false;
2841  }
2842 
2843  /// Price quotation method.
2845  {
2846  const BlockLength offset = 195;
2847  const BlockLength length = 5;
2848  const SchemaVersion since = 10;
2849 
2850  return fixedStr<length>(offset, since);
2851  }
2852 
2853  /// Risk Set identifies the list of instruments sharing credit
2854  /// limits set up.
2855  StrRef riskSet() const
2856  {
2857  const BlockLength offset = 200;
2858  const BlockLength length = 6;
2859  const SchemaVersion since = 10;
2860 
2861  return fixedStr<length>(offset, since);
2862  }
2863 
2864  /// Market Set defines the bilateral relationship and Self
2865  /// Match Prevention configuration for eligible markets.
2867  {
2868  const BlockLength offset = 206;
2869  const BlockLength length = 6;
2870  const SchemaVersion since = 10;
2871 
2872  return fixedStr<length>(offset, since);
2873  }
2874 
2875  /// External unique instrument ID.
2877  {
2878  typedef NullUInt64 Null;
2879 
2880  const BlockLength offset = 212;
2881  const SchemaVersion since = 10;
2882 
2883  return ordinary(value, offset, Null(), since);
2884  }
2885 
2886  /// Long name of the instrument.
2888  {
2889  const BlockLength offset = 220;
2890  const BlockLength length = 35;
2891  const SchemaVersion since = 10;
2892 
2893  return fixedStr<length>(offset, since);
2894  }
2895 
2896  /// Returns instance of Events repeating group.
2897  Events events() const
2898  {
2899  return groups().head<Events>();
2900  }
2901 
2902  /// Returns instance of FeedTypes repeating group.
2903  FeedTypes feedTypes() const
2904  {
2905  return groups().tail<Events>().head<FeedTypes>();
2906  }
2907 
2908  /// Returns instance of InstAttrib repeating group.
2909  InstAttrib instAttrib() const
2910  {
2911  return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
2912  }
2913 
2914  /// Returns instance of LotTypeRules repeating group.
2915  LotTypeRules lotTypeRules() const
2916  {
2917  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
2918  }
2919 
2920  /// Returns instance of Legs repeating group.
2921  Legs legs() const
2922  {
2923  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().head<Legs>();
2924  }
2925 
2926  /// Size of message body in bytes.
2929  {
2930  if (version >= 10)
2931  return 255;
2932 
2933  return 195;
2934  }
2935 
2936  /// Returns class name.
2938  static const Char* className()
2939  {
2940  return "InstrumentDefinitionSpread56";
2941  }
2942 
2943  /// FIX message type.
2945  static StrRef fixType()
2946  {
2947  return toStrRef("d");
2948  }
2949 };
2950 
2951 /// SecurityStatus.
2953 {
2954  /// Message template ID from SBE schema.
2955  enum
2956  {
2957  TemplateId = 30
2958  };
2959 
2960  /// Initializes blank instance.
2962 
2963  /// Initializes instance over given memory block.
2964  SecurityStatus30(const void* data, EncodedLength length)
2965  : BinaryMessage(data, length)
2966  {
2967  assert(TemplateId == templateId());
2968 
2969  const SchemaVersion current = version();
2971 
2972  if (current < since)
2973  throwBadMessageVersion(className(), current, since);
2974 
2975  if (length < blockLength(version()))
2976  throwBadBinaryData(className());
2977  }
2978 
2979  /// Start of event processing time in number of nanoseconds
2980  /// since Unix epoch.
2982  {
2983  const BlockLength offset = 0;
2984 
2985  return ordinary<Timestamp>(offset);
2986  }
2987 
2988  /// Security Group.
2990  {
2991  const BlockLength offset = 8;
2992  const BlockLength length = 6;
2993 
2994  return fixedStr<length>(offset);
2995  }
2996 
2997  /// Product Code within Security Group specified.
2998  StrRef asset() const
2999  {
3000  const BlockLength offset = 14;
3001  const BlockLength length = 6;
3002 
3003  return fixedStr<length>(offset);
3004  }
3005 
3006  /// If this tag is present, 35=f message is sent for the
3007  /// instrument.
3008  bool securityId(Int32& value) const
3009  {
3010  typedef NullInt32 Null;
3011 
3012  const BlockLength offset = 20;
3013 
3014  return ordinary(value, offset, Null());
3015  }
3016 
3017  /// Trade Session Date.
3019  {
3020  typedef NullLocalMktDate Null;
3021  typedef LocalMktDate FieldValue;
3022 
3023  const BlockLength offset = 24;
3024 
3025  FieldValue fieldValue;
3026 
3027  if (ordinary(fieldValue, offset, Null()))
3028  {
3029  value = localMktDateToTimestamp(fieldValue);
3030  return true;
3031  }
3032  return false;
3033  }
3034 
3035  /// Bitmap field of eight Boolean type indicators reflecting
3036  /// the end of updates for a given Globex event.
3038  {
3039  const BlockLength offset = 26;
3040 
3041  return ordinary<MatchEventIndicator>(offset);
3042  }
3043 
3044  /// Identifies the trading status applicable to the instrument
3045  /// or Security Group.
3047  {
3048  typedef NullUInt8 Null;
3049 
3050  const BlockLength offset = 27;
3051 
3052  return enumeration<SecurityTradingStatus>(value, offset, Null());
3053  }
3054 
3055  /// Identifies the reason for the status change.
3057  {
3058  const BlockLength offset = 28;
3059 
3060  return enumeration<HaltReason>(offset);
3061  }
3062 
3063  /// Identifies an additional event or a rule related to the
3064  /// status.
3066  {
3067  const BlockLength offset = 29;
3068 
3069  return enumeration<SecurityTradingEvent>(offset);
3070  }
3071 
3072  /// Size of message body in bytes.
3075  {
3076  return 30;
3077  }
3078 
3079  /// Returns class name.
3081  static const Char* className()
3082  {
3083  return "SecurityStatus30";
3084  }
3085 
3086  /// FIX message type.
3088  static StrRef fixType()
3089  {
3090  return toStrRef("f");
3091  }
3092 };
3093 
3094 /// MDIncrementalRefreshBook.
3096 {
3097  /// Message template ID from SBE schema.
3098  enum
3099  {
3100  TemplateId = 46
3101  };
3102 
3103  /// Number of entries in Market Data message.
3104  /// Entry of Entry repeating group.
3105  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
3106  {
3107  /// Aliases base class type.
3109 
3110  /// Initializes blank instance.
3111  Entry() {}
3112 
3113  /// Initializes instance of given
3114  /// version over given memory block.
3115  Entry(const void* data, EncodedLength length, SchemaVersion version)
3116  : Base(data, length, version)
3117  {
3118  if (length < blockLength(version))
3119  throwBadBinaryData(className());
3120  }
3121 
3122  /// Market Data entry price.
3123  bool entryPx(Decimal& value) const
3124  {
3125  typedef NullPRICE9 Null;
3126 
3127  const BlockLength offset = 0;
3128 
3129  return decimal(value, offset, Null());
3130  }
3131 
3132  /// Market Data entry size.
3133  bool entrySize(Int32& value) const
3134  {
3135  typedef NullInt32 Null;
3136 
3137  const BlockLength offset = 8;
3138 
3139  return ordinary(value, offset, Null());
3140  }
3141 
3142  /// Security ID.
3144  {
3145  const BlockLength offset = 12;
3146 
3147  return ordinary<Int32>(offset);
3148  }
3149 
3150  /// Market Data entry sequence number per instrument update.
3151  UInt32 rptSeq() const
3152  {
3153  const BlockLength offset = 16;
3154 
3155  return ordinary<UInt32>(offset);
3156  }
3157 
3158  /// In Book entry - aggregate number of orders at given price
3159  /// level.
3161  {
3162  typedef NullInt32 Null;
3163 
3164  const BlockLength offset = 20;
3165 
3166  return ordinary(value, offset, Null());
3167  }
3168 
3169  /// Aggregate book level.
3171  {
3172  const BlockLength offset = 24;
3173 
3174  return ordinary<UInt8>(offset);
3175  }
3176 
3177  /// Market Data update action.
3179  {
3180  const BlockLength offset = 25;
3181 
3182  return enumeration<UpdateAction>(offset);
3183  }
3184 
3185  /// Market Data entry type.
3187  {
3188  const BlockLength offset = 26;
3189 
3190  return enumeration<EntryTypeBook>(offset);
3191  }
3192 
3193  /// Tradeable qty.
3195  {
3196  typedef NullInt32 Null;
3197 
3198  const BlockLength offset = 27;
3199  const SchemaVersion since = 10;
3200 
3201  return ordinary(value, offset, Null(), since);
3202  }
3203 
3204  /// Returns size of entry body in bytes
3205  /// for given version of message template.
3208  {
3209  if (version >= 10)
3210  return 31;
3211 
3212  return 27;
3213  }
3214 
3215  /// Entity class name.
3217  static const Char* className()
3218  {
3219  return "IncrementalRefreshBook46.Entry";
3220  }
3221  };
3222 
3223  /// Repeating group containing Entry entries.
3225 
3226  /// Number of OrderID entries.
3227  /// Entry of OrderIDEntry repeating group.
3228  struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
3229  {
3230  /// Aliases base class type.
3232 
3233  /// Initializes blank instance.
3235 
3236  /// Initializes instance of given
3237  /// version over given memory block.
3238  OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
3239  : Base(data, length, version)
3240  {
3241  if (length < blockLength(version))
3242  throwBadBinaryData(className());
3243  }
3244 
3245  /// Unique Order ID.
3246  UInt64 orderId() const
3247  {
3248  const BlockLength offset = 0;
3249 
3250  return ordinary<UInt64>(offset);
3251  }
3252 
3253  /// Order priority for execution on the order book.
3255  {
3256  typedef NullUInt64 Null;
3257 
3258  const BlockLength offset = 8;
3259 
3260  return ordinary(value, offset, Null());
3261  }
3262 
3263  /// Visible qty of order.
3264  bool displayQty(Int32& value) const
3265  {
3266  typedef NullInt32 Null;
3267 
3268  const BlockLength offset = 16;
3269 
3270  return ordinary(value, offset, Null());
3271  }
3272 
3273  /// Reference to corresponding Price and Security ID, sequence
3274  /// of MD entry in the message.
3275  bool referenceId(UInt8& value) const
3276  {
3277  typedef NullUInt8 Null;
3278 
3279  const BlockLength offset = 20;
3280 
3281  return ordinary(value, offset, Null());
3282  }
3283 
3284  /// Order book update action to be applied to the order
3285  /// referenced by OrderID.
3287  {
3288  const BlockLength offset = 21;
3289 
3290  return enumeration<OrderUpdateAction>(offset);
3291  }
3292 
3293  /// Returns size of entry body in bytes
3294  /// for given version of message template.
3297  {
3298  return 22;
3299  }
3300 
3301  /// Entity class name.
3303  static const Char* className()
3304  {
3305  return "IncrementalRefreshBook46.OrderIDEntry";
3306  }
3307  };
3308 
3309  /// Repeating group containing OrderIDEntry entries.
3311 
3312  /// Initializes blank instance.
3314 
3315  /// Initializes instance over given memory block.
3316  IncrementalRefreshBook46(const void* data, EncodedLength length)
3317  : BinaryMessage(data, length)
3318  {
3319  assert(TemplateId == templateId());
3320 
3321  const SchemaVersion current = version();
3323 
3324  if (current < since)
3325  throwBadMessageVersion(className(), current, since);
3326 
3327  if (length < blockLength(version()))
3328  throwBadBinaryData(className());
3329  }
3330 
3331  /// Start of event processing time in number of nanoseconds
3332  /// since Unix epoch.
3334  {
3335  const BlockLength offset = 0;
3336 
3337  return ordinary<Timestamp>(offset);
3338  }
3339 
3340  /// Bitmap field of eight Boolean type indicators reflecting
3341  /// the end of updates for a given Globex event.
3343  {
3344  const BlockLength offset = 8;
3345 
3346  return ordinary<MatchEventIndicator>(offset);
3347  }
3348 
3349  /// Returns instance of Entries repeating group.
3350  Entries entries() const
3351  {
3352  return groups().head<Entries>();
3353  }
3354 
3355  /// Returns instance of OrderIDEntries repeating group.
3356  OrderIDEntries orderIdEntries() const
3357  {
3358  return groups().tail<Entries>().head<OrderIDEntries>();
3359  }
3360 
3361  /// Size of message body in bytes.
3364  {
3365  return 9;
3366  }
3367 
3368  /// Returns class name.
3370  static const Char* className()
3371  {
3372  return "IncrementalRefreshBook46";
3373  }
3374 
3375  /// FIX message type.
3377  static StrRef fixType()
3378  {
3379  return toStrRef("X");
3380  }
3381 };
3382 
3383 /// MDIncrementalRefreshDailyStatistics.
3385 {
3386  /// Message template ID from SBE schema.
3387  enum
3388  {
3389  TemplateId = 49
3390  };
3391 
3392  /// Number of entries in Market Data message.
3393  /// Entry of Entry repeating group.
3394  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
3395  {
3396  /// Aliases base class type.
3398 
3399  /// Initializes blank instance.
3400  Entry() {}
3401 
3402  /// Initializes instance of given
3403  /// version over given memory block.
3404  Entry(const void* data, EncodedLength length, SchemaVersion version)
3405  : Base(data, length, version)
3406  {
3407  if (length < blockLength(version))
3408  throwBadBinaryData(className());
3409  }
3410 
3411  /// Market Data entry price.
3412  bool entryPx(Decimal& value) const
3413  {
3414  typedef NullPRICE9 Null;
3415 
3416  const BlockLength offset = 0;
3417 
3418  return decimal(value, offset, Null());
3419  }
3420 
3421  /// Market Data entry size.
3422  bool entrySize(Int32& value) const
3423  {
3424  typedef NullInt32 Null;
3425 
3426  const BlockLength offset = 8;
3427 
3428  return ordinary(value, offset, Null());
3429  }
3430 
3431  /// Security ID.
3433  {
3434  const BlockLength offset = 12;
3435 
3436  return ordinary<Int32>(offset);
3437  }
3438 
3439  /// Market Data entry sequence number per instrument update.
3440  UInt32 rptSeq() const
3441  {
3442  const BlockLength offset = 16;
3443 
3444  return ordinary<UInt32>(offset);
3445  }
3446 
3447  /// Indicates trade session date corresponding to a statistic
3448  /// entry.
3450  {
3451  typedef NullLocalMktDate Null;
3452  typedef LocalMktDate FieldValue;
3453 
3454  const BlockLength offset = 20;
3455 
3456  FieldValue fieldValue;
3457 
3458  if (ordinary(fieldValue, offset, Null()))
3459  {
3460  value = localMktDateToTimestamp(fieldValue);
3461  return true;
3462  }
3463  return false;
3464  }
3465 
3466  /// Bitmap field of eight Boolean type indicators representing
3467  /// settlement price type.
3469  {
3470  const BlockLength offset = 22;
3471 
3472  return ordinary<SettlPriceType>(offset);
3473  }
3474 
3475  /// Market Data update action.
3477  {
3478  const BlockLength offset = 23;
3479 
3480  return enumeration<UpdateAction>(offset);
3481  }
3482 
3483  /// Market Data entry type.
3485  {
3486  const BlockLength offset = 24;
3487 
3488  return enumeration<EntryTypeDailyStatistics>(offset);
3489  }
3490 
3491  /// Returns size of entry body in bytes
3492  /// for given version of message template.
3495  {
3496  return 25;
3497  }
3498 
3499  /// Entity class name.
3501  static const Char* className()
3502  {
3503  return "IncrementalRefreshDailyStatistics49.Entry";
3504  }
3505  };
3506 
3507  /// Repeating group containing Entry entries.
3509 
3510  /// Initializes blank instance.
3512 
3513  /// Initializes instance over given memory block.
3515  : BinaryMessage(data, length)
3516  {
3517  assert(TemplateId == templateId());
3518 
3519  const SchemaVersion current = version();
3521 
3522  if (current < since)
3523  throwBadMessageVersion(className(), current, since);
3524 
3525  if (length < blockLength(version()))
3526  throwBadBinaryData(className());
3527  }
3528 
3529  /// Start of event processing time in number of nanoseconds
3530  /// since Unix epoch.
3532  {
3533  const BlockLength offset = 0;
3534 
3535  return ordinary<Timestamp>(offset);
3536  }
3537 
3538  /// Bitmap field of eight Boolean type indicators reflecting
3539  /// the end of updates for a given Globex event.
3541  {
3542  const BlockLength offset = 8;
3543 
3544  return ordinary<MatchEventIndicator>(offset);
3545  }
3546 
3547  /// Returns instance of Entries repeating group.
3548  Entries entries() const
3549  {
3550  return groups().head<Entries>();
3551  }
3552 
3553  /// Size of message body in bytes.
3556  {
3557  return 9;
3558  }
3559 
3560  /// Returns class name.
3562  static const Char* className()
3563  {
3564  return "IncrementalRefreshDailyStatistics49";
3565  }
3566 
3567  /// FIX message type.
3569  static StrRef fixType()
3570  {
3571  return toStrRef("X");
3572  }
3573 };
3574 
3575 /// MDIncrementalRefreshLimitsBanding.
3577 {
3578  /// Message template ID from SBE schema.
3579  enum
3580  {
3581  TemplateId = 50
3582  };
3583 
3584  /// Number of entries in Market Data message.
3585  /// Entry of Entry repeating group.
3586  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
3587  {
3588  /// Aliases base class type.
3590 
3591  /// Initializes blank instance.
3592  Entry() {}
3593 
3594  /// Initializes instance of given
3595  /// version over given memory block.
3596  Entry(const void* data, EncodedLength length, SchemaVersion version)
3597  : Base(data, length, version)
3598  {
3599  if (length < blockLength(version))
3600  throwBadBinaryData(className());
3601  }
3602 
3603  /// Upper price threshold for the instrument.
3605  {
3606  typedef NullPRICE9 Null;
3607 
3608  const BlockLength offset = 0;
3609 
3610  return decimal(value, offset, Null());
3611  }
3612 
3613  /// Lower price threshold for the instrument.
3615  {
3616  typedef NullPRICE9 Null;
3617 
3618  const BlockLength offset = 8;
3619 
3620  return decimal(value, offset, Null());
3621  }
3622 
3623  /// Differential static value for price banding.
3625  {
3626  typedef NullPRICE9 Null;
3627 
3628  const BlockLength offset = 16;
3629 
3630  return decimal(value, offset, Null());
3631  }
3632 
3633  /// Security ID.
3635  {
3636  const BlockLength offset = 24;
3637 
3638  return ordinary<Int32>(offset);
3639  }
3640 
3641  /// MD Entry sequence number per instrument update.
3642  UInt32 rptSeq() const
3643  {
3644  const BlockLength offset = 28;
3645 
3646  return ordinary<UInt32>(offset);
3647  }
3648 
3649  /// Market Data entry update action. In order to delete
3650  /// banding value, high or low limit, the deleted price field
3651  /// is populated with a NULL.
3653  {
3654  return UpdateActionNew();
3655  }
3656 
3657  /// Market Data entry type.
3659  {
3660  return EntryTypeLimits();
3661  }
3662 
3663  /// Returns size of entry body in bytes
3664  /// for given version of message template.
3667  {
3668  return 32;
3669  }
3670 
3671  /// Entity class name.
3673  static const Char* className()
3674  {
3675  return "IncrementalRefreshLimitsBanding50.Entry";
3676  }
3677  };
3678 
3679  /// Repeating group containing Entry entries.
3681 
3682  /// Initializes blank instance.
3684 
3685  /// Initializes instance over given memory block.
3687  : BinaryMessage(data, length)
3688  {
3689  assert(TemplateId == templateId());
3690 
3691  const SchemaVersion current = version();
3693 
3694  if (current < since)
3695  throwBadMessageVersion(className(), current, since);
3696 
3697  if (length < blockLength(version()))
3698  throwBadBinaryData(className());
3699  }
3700 
3701  /// Start of event processing time in number of nanoseconds
3702  /// since Unix epoch.
3704  {
3705  const BlockLength offset = 0;
3706 
3707  return ordinary<Timestamp>(offset);
3708  }
3709 
3710  /// Bitmap field of eight Boolean type indicators reflecting
3711  /// the end of updates for a given Globex event.
3713  {
3714  const BlockLength offset = 8;
3715 
3716  return ordinary<MatchEventIndicator>(offset);
3717  }
3718 
3719  /// Returns instance of Entries repeating group.
3720  Entries entries() const
3721  {
3722  return groups().head<Entries>();
3723  }
3724 
3725  /// Size of message body in bytes.
3728  {
3729  return 9;
3730  }
3731 
3732  /// Returns class name.
3734  static const Char* className()
3735  {
3736  return "IncrementalRefreshLimitsBanding50";
3737  }
3738 
3739  /// FIX message type.
3741  static StrRef fixType()
3742  {
3743  return toStrRef("X");
3744  }
3745 };
3746 
3747 /// MDIncrementalRefreshSessionStatistics.
3749 {
3750  /// Message template ID from SBE schema.
3751  enum
3752  {
3753  TemplateId = 51
3754  };
3755 
3756  /// Number of entries in Market Data message.
3757  /// Entry of Entry repeating group.
3758  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
3759  {
3760  /// Aliases base class type.
3762 
3763  /// Initializes blank instance.
3764  Entry() {}
3765 
3766  /// Initializes instance of given
3767  /// version over given memory block.
3768  Entry(const void* data, EncodedLength length, SchemaVersion version)
3769  : Base(data, length, version)
3770  {
3771  if (length < blockLength(version))
3772  throwBadBinaryData(className());
3773  }
3774 
3775  /// Market Data entry price.
3777  {
3778  const BlockLength offset = 0;
3779 
3780  return decimal<PRICE9>(offset);
3781  }
3782 
3783  /// Security ID.
3785  {
3786  const BlockLength offset = 8;
3787 
3788  return ordinary<Int32>(offset);
3789  }
3790 
3791  /// MD Entry sequence number per instrument update.
3792  UInt32 rptSeq() const
3793  {
3794  const BlockLength offset = 12;
3795 
3796  return ordinary<UInt32>(offset);
3797  }
3798 
3799  /// Flag describing IOP and Open Price entries.
3801  {
3802  typedef NullUInt8 Null;
3803 
3804  const BlockLength offset = 16;
3805 
3806  return enumeration<OpenCloseSettlFlag>(value, offset, Null());
3807  }
3808 
3809  /// Market Data update action.
3811  {
3812  const BlockLength offset = 17;
3813 
3814  return enumeration<UpdateAction>(offset);
3815  }
3816 
3817  /// Market Data entry type.
3819  {
3820  const BlockLength offset = 18;
3821 
3822  return enumeration<EntryTypeStatistics>(offset);
3823  }
3824 
3825  /// Indicative Opening Quantity.
3826  bool entrySize(Int32& value) const
3827  {
3828  typedef NullInt32 Null;
3829 
3830  const BlockLength offset = 19;
3831 
3832  return ordinary(value, offset, Null());
3833  }
3834 
3835  /// Returns size of entry body in bytes
3836  /// for given version of message template.
3839  {
3840  return 23;
3841  }
3842 
3843  /// Entity class name.
3845  static const Char* className()
3846  {
3847  return "IncrementalRefreshSessionStatistics51.Entry";
3848  }
3849  };
3850 
3851  /// Repeating group containing Entry entries.
3853 
3854  /// Initializes blank instance.
3856 
3857  /// Initializes instance over given memory block.
3859  : BinaryMessage(data, length)
3860  {
3861  assert(TemplateId == templateId());
3862 
3863  const SchemaVersion current = version();
3865 
3866  if (current < since)
3867  throwBadMessageVersion(className(), current, since);
3868 
3869  if (length < blockLength(version()))
3870  throwBadBinaryData(className());
3871  }
3872 
3873  /// Start of event processing time in number of nanoseconds
3874  /// since Unix epoch.
3876  {
3877  const BlockLength offset = 0;
3878 
3879  return ordinary<Timestamp>(offset);
3880  }
3881 
3882  /// Bitmap field of eight Boolean type indicators reflecting
3883  /// the end of updates for a given Globex event.
3885  {
3886  const BlockLength offset = 8;
3887 
3888  return ordinary<MatchEventIndicator>(offset);
3889  }
3890 
3891  /// Returns instance of Entries repeating group.
3892  Entries entries() const
3893  {
3894  return groups().head<Entries>();
3895  }
3896 
3897  /// Size of message body in bytes.
3900  {
3901  return 9;
3902  }
3903 
3904  /// Returns class name.
3906  static const Char* className()
3907  {
3908  return "IncrementalRefreshSessionStatistics51";
3909  }
3910 
3911  /// FIX message type.
3913  static StrRef fixType()
3914  {
3915  return toStrRef("X");
3916  }
3917 };
3918 
3919 /// MDIncrementalRefreshVolume.
3921 {
3922  /// Message template ID from SBE schema.
3923  enum
3924  {
3925  TemplateId = 37
3926  };
3927 
3928  /// Number of entries in Market Data message.
3929  /// Entry of Entry repeating group.
3930  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
3931  {
3932  /// Aliases base class type.
3934 
3935  /// Initializes blank instance.
3936  Entry() {}
3937 
3938  /// Initializes instance of given
3939  /// version over given memory block.
3940  Entry(const void* data, EncodedLength length, SchemaVersion version)
3941  : Base(data, length, version)
3942  {
3943  if (length < blockLength(version))
3944  throwBadBinaryData(className());
3945  }
3946 
3947  /// Cumulative traded volume.
3949  {
3950  const BlockLength offset = 0;
3951 
3952  return ordinary<Int32>(offset);
3953  }
3954 
3955  /// Security ID.
3957  {
3958  const BlockLength offset = 4;
3959 
3960  return ordinary<Int32>(offset);
3961  }
3962 
3963  /// Market Data entry sequence number per instrument update.
3964  UInt32 rptSeq() const
3965  {
3966  const BlockLength offset = 8;
3967 
3968  return ordinary<UInt32>(offset);
3969  }
3970 
3971  /// Market Data update action.
3973  {
3974  const BlockLength offset = 12;
3975 
3976  return enumeration<UpdateAction>(offset);
3977  }
3978 
3979  /// Electronic Volume entry provides cumulative session trade
3980  /// volume updated with the event.
3982  {
3983  return EntryTypeVol();
3984  }
3985 
3986  /// Returns size of entry body in bytes
3987  /// for given version of message template.
3990  {
3991  return 13;
3992  }
3993 
3994  /// Entity class name.
3996  static const Char* className()
3997  {
3998  return "IncrementalRefreshVolume37.Entry";
3999  }
4000  };
4001 
4002  /// Repeating group containing Entry entries.
4004 
4005  /// Initializes blank instance.
4007 
4008  /// Initializes instance over given memory block.
4009  IncrementalRefreshVolume37(const void* data, EncodedLength length)
4010  : BinaryMessage(data, length)
4011  {
4012  assert(TemplateId == templateId());
4013 
4014  const SchemaVersion current = version();
4016 
4017  if (current < since)
4018  throwBadMessageVersion(className(), current, since);
4019 
4020  if (length < blockLength(version()))
4021  throwBadBinaryData(className());
4022  }
4023 
4024  /// Start of event processing time in number of nanoseconds
4025  /// since Unix epoch.
4027  {
4028  const BlockLength offset = 0;
4029 
4030  return ordinary<Timestamp>(offset);
4031  }
4032 
4033  /// Bitmap field of eight Boolean type indicators reflecting
4034  /// the end of updates for a given Globex event.
4036  {
4037  const BlockLength offset = 8;
4038 
4039  return ordinary<MatchEventIndicator>(offset);
4040  }
4041 
4042  /// Returns instance of Entries repeating group.
4043  Entries entries() const
4044  {
4045  return groups().head<Entries>();
4046  }
4047 
4048  /// Size of message body in bytes.
4051  {
4052  return 9;
4053  }
4054 
4055  /// Returns class name.
4057  static const Char* className()
4058  {
4059  return "IncrementalRefreshVolume37";
4060  }
4061 
4062  /// FIX message type.
4064  static StrRef fixType()
4065  {
4066  return toStrRef("X");
4067  }
4068 };
4069 
4070 /// SnapshotFullRefresh.
4072 {
4073  /// Message template ID from SBE schema.
4074  enum
4075  {
4076  TemplateId = 52
4077  };
4078 
4079  /// Number of entries in Market Data message.
4080  /// Entry of Entry repeating group.
4081  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
4082  {
4083  /// Aliases base class type.
4085 
4086  /// Initializes blank instance.
4087  Entry() {}
4088 
4089  /// Initializes instance of given
4090  /// version over given memory block.
4091  Entry(const void* data, EncodedLength length, SchemaVersion version)
4092  : Base(data, length, version)
4093  {
4094  if (length < blockLength(version))
4095  throwBadBinaryData(className());
4096  }
4097 
4098  /// Market Data entry price.
4099  bool entryPx(Decimal& value) const
4100  {
4101  typedef NullPRICE9 Null;
4102 
4103  const BlockLength offset = 0;
4104 
4105  return decimal(value, offset, Null());
4106  }
4107 
4108  /// Market Data entry quantity.
4109  bool entrySize(Int32& value) const
4110  {
4111  typedef NullInt32 Null;
4112 
4113  const BlockLength offset = 8;
4114 
4115  return ordinary(value, offset, Null());
4116  }
4117 
4118  /// Aggregate number of orders at the given price level.
4120  {
4121  typedef NullInt32 Null;
4122 
4123  const BlockLength offset = 12;
4124 
4125  return ordinary(value, offset, Null());
4126  }
4127 
4128  /// Aggregate book position.
4129  bool priceLevel(Int8& value) const
4130  {
4131  typedef NullInt8 Null;
4132 
4133  const BlockLength offset = 16;
4134 
4135  return ordinary(value, offset, Null());
4136  }
4137 
4138  /// Indicates the date of trade session corresponding to a
4139  /// statistic entry.
4141  {
4142  typedef NullLocalMktDate Null;
4143  typedef LocalMktDate FieldValue;
4144 
4145  const BlockLength offset = 17;
4146 
4147  FieldValue fieldValue;
4148 
4149  if (ordinary(fieldValue, offset, Null()))
4150  {
4151  value = localMktDateToTimestamp(fieldValue);
4152  return true;
4153  }
4154  return false;
4155  }
4156 
4157  /// Flag describing Open Price entry.
4159  {
4160  typedef NullUInt8 Null;
4161 
4162  const BlockLength offset = 19;
4163 
4164  return enumeration<OpenCloseSettlFlag>(value, offset, Null());
4165  }
4166 
4167  /// Bitmap field of eight Boolean type indicators representing
4168  /// settlement price type.
4170  {
4171  const BlockLength offset = 20;
4172 
4173  return ordinary<SettlPriceType>(offset);
4174  }
4175 
4176  /// Market Data entry type.
4178  {
4179  const BlockLength offset = 21;
4180 
4181  return enumeration<EntryType>(offset);
4182  }
4183 
4184  /// Returns size of entry body in bytes
4185  /// for given version of message template.
4188  {
4189  return 22;
4190  }
4191 
4192  /// Entity class name.
4194  static const Char* className()
4195  {
4196  return "SnapshotFullRefresh52.Entry";
4197  }
4198  };
4199 
4200  /// Repeating group containing Entry entries.
4202 
4203  /// Initializes blank instance.
4205 
4206  /// Initializes instance over given memory block.
4207  SnapshotFullRefresh52(const void* data, EncodedLength length)
4208  : BinaryMessage(data, length)
4209  {
4210  assert(TemplateId == templateId());
4211 
4212  const SchemaVersion current = version();
4214 
4215  if (current < since)
4216  throwBadMessageVersion(className(), current, since);
4217 
4218  if (length < blockLength(version()))
4219  throwBadBinaryData(className());
4220  }
4221 
4222  /// Sequence number of the last Incremental feed packet
4223  /// processed. This value is used to synchronize the snapshot
4224  /// loop with the real-time feed.
4226  {
4227  const BlockLength offset = 0;
4228 
4229  return ordinary<UInt32>(offset);
4230  }
4231 
4232  /// Total number of messages replayed in the loop.
4234  {
4235  const BlockLength offset = 4;
4236 
4237  return ordinary<UInt32>(offset);
4238  }
4239 
4240  /// Security ID.
4242  {
4243  const BlockLength offset = 8;
4244 
4245  return ordinary<Int32>(offset);
4246  }
4247 
4248  /// Sequence number of the last Market Data entry processed
4249  /// for the instrument.
4250  UInt32 rptSeq() const
4251  {
4252  const BlockLength offset = 12;
4253 
4254  return ordinary<UInt32>(offset);
4255  }
4256 
4257  /// Timestamp of the last event security participated in, sent
4258  /// as number of nanoseconds since Unix epoch.
4260  {
4261  const BlockLength offset = 16;
4262 
4263  return ordinary<Timestamp>(offset);
4264  }
4265 
4266  /// UTC Date and time of last Security Definition add, update
4267  /// or delete on a given Market Data channel.
4269  {
4270  const BlockLength offset = 24;
4271 
4272  return ordinary<Timestamp>(offset);
4273  }
4274 
4275  /// Trade session date sent as number of days since Unix epoch.
4277  {
4278  typedef NullLocalMktDate Null;
4279  typedef LocalMktDate FieldValue;
4280 
4281  const BlockLength offset = 32;
4282 
4283  FieldValue fieldValue;
4284 
4285  if (ordinary(fieldValue, offset, Null()))
4286  {
4287  value = localMktDateToTimestamp(fieldValue);
4288  return true;
4289  }
4290  return false;
4291  }
4292 
4293  /// Identifies the current trading state of the instrument.
4295  {
4296  typedef NullUInt8 Null;
4297 
4298  const BlockLength offset = 34;
4299 
4300  return enumeration<SecurityTradingStatus>(value, offset, Null());
4301  }
4302 
4303  /// Upper price threshold for the instrument.
4305  {
4306  typedef NullPRICE9 Null;
4307 
4308  const BlockLength offset = 35;
4309 
4310  return decimal(value, offset, Null());
4311  }
4312 
4313  /// Lower price threshold for the instrument.
4315  {
4316  typedef NullPRICE9 Null;
4317 
4318  const BlockLength offset = 43;
4319 
4320  return decimal(value, offset, Null());
4321  }
4322 
4323  /// Differential value for price banding.
4325  {
4326  typedef NullPRICE9 Null;
4327 
4328  const BlockLength offset = 51;
4329 
4330  return decimal(value, offset, Null());
4331  }
4332 
4333  /// Returns instance of Entries repeating group.
4334  Entries entries() const
4335  {
4336  return groups().head<Entries>();
4337  }
4338 
4339  /// Size of message body in bytes.
4342  {
4343  return 59;
4344  }
4345 
4346  /// Returns class name.
4348  static const Char* className()
4349  {
4350  return "SnapshotFullRefresh52";
4351  }
4352 
4353  /// FIX message type.
4355  static StrRef fixType()
4356  {
4357  return toStrRef("W");
4358  }
4359 };
4360 
4361 /// QuoteRequest.
4363 {
4364  /// Message template ID from SBE schema.
4365  enum
4366  {
4367  TemplateId = 39
4368  };
4369 
4370  /// Indicates the number of repeating symbols specified.
4371  /// Entry of RelatedSymEntry repeating group.
4372  struct ONIXS_CMEMDH_LTWT RelatedSymEntry : BinaryGroupEntry<GroupSize::BlockLength>
4373  {
4374  /// Aliases base class type.
4376 
4377  /// Initializes blank instance.
4379 
4380  /// Initializes instance of given
4381  /// version over given memory block.
4382  RelatedSymEntry(const void* data, EncodedLength length, SchemaVersion version)
4383  : Base(data, length, version)
4384  {
4385  if (length < blockLength(version))
4386  throwBadBinaryData(className());
4387  }
4388 
4389  /// Instrument Name or Symbol.
4390  StrRef symbol() const
4391  {
4392  const BlockLength offset = 0;
4393  const BlockLength length = 20;
4394 
4395  return fixedStr<length>(offset);
4396  }
4397 
4398  /// Security ID.
4400  {
4401  const BlockLength offset = 20;
4402 
4403  return ordinary<Int32>(offset);
4404  }
4405 
4406  /// Quantity requested.
4407  bool orderQty(Int32& value) const
4408  {
4409  typedef NullInt32 Null;
4410 
4411  const BlockLength offset = 24;
4412 
4413  return ordinary(value, offset, Null());
4414  }
4415 
4416  /// Type of quote requested.
4417  Int8 quoteType() const
4418  {
4419  const BlockLength offset = 28;
4420 
4421  return ordinary<Int8>(offset);
4422  }
4423 
4424  /// Side requested.
4425  bool side(Int8& value) const
4426  {
4427  typedef NullInt8 Null;
4428 
4429  const BlockLength offset = 29;
4430 
4431  return ordinary(value, offset, Null());
4432  }
4433 
4434  /// Returns size of entry body in bytes
4435  /// for given version of message template.
4438  {
4439  return 30;
4440  }
4441 
4442  /// Entity class name.
4444  static const Char* className()
4445  {
4446  return "QuoteRequest39.RelatedSymEntry";
4447  }
4448  };
4449 
4450  /// Repeating group containing RelatedSymEntry entries.
4452 
4453  /// Initializes blank instance.
4455 
4456  /// Initializes instance over given memory block.
4457  QuoteRequest39(const void* data, EncodedLength length)
4458  : BinaryMessage(data, length)
4459  {
4460  assert(TemplateId == templateId());
4461 
4462  const SchemaVersion current = version();
4464 
4465  if (current < since)
4466  throwBadMessageVersion(className(), current, since);
4467 
4468  if (length < blockLength(version()))
4469  throwBadBinaryData(className());
4470  }
4471 
4472  /// Start of event processing time in number of nanoseconds
4473  /// since Unix epoch.
4475  {
4476  const BlockLength offset = 0;
4477 
4478  return ordinary<Timestamp>(offset);
4479  }
4480 
4481  /// Quote Request ID defined by the exchange.
4483  {
4484  const BlockLength offset = 8;
4485  const BlockLength length = 23;
4486 
4487  return fixedStr<length>(offset);
4488  }
4489 
4490  /// Bitmap field of eight Boolean type indicators reflecting
4491  /// the end of updates for a given Globex event.
4493  {
4494  const BlockLength offset = 31;
4495 
4496  return ordinary<MatchEventIndicator>(offset);
4497  }
4498 
4499  /// Returns instance of RelatedSym repeating group.
4500  RelatedSym relatedSym() const
4501  {
4502  return groups().head<RelatedSym>();
4503  }
4504 
4505  /// Size of message body in bytes.
4508  {
4509  return 32;
4510  }
4511 
4512  /// Returns class name.
4514  static const Char* className()
4515  {
4516  return "QuoteRequest39";
4517  }
4518 
4519  /// FIX message type.
4521  static StrRef fixType()
4522  {
4523  return toStrRef("R");
4524  }
4525 };
4526 
4527 /// MDInstrumentDefinitionOption.
4529 {
4530  /// Message template ID from SBE schema.
4531  enum
4532  {
4533  TemplateId = 55
4534  };
4535 
4536  /// Number of EventType entries.
4537  /// Entry of EventsEntry repeating group.
4538  struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
4539  {
4540  /// Aliases base class type.
4542 
4543  /// Initializes blank instance.
4545 
4546  /// Initializes instance of given
4547  /// version over given memory block.
4548  EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
4549  : Base(data, length, version)
4550  {
4551  if (length < blockLength(version))
4552  throwBadBinaryData(className());
4553  }
4554 
4555  /// Code to represent the type of event.
4557  {
4558  const BlockLength offset = 0;
4559 
4560  return enumeration<EventType>(offset);
4561  }
4562 
4563  /// Date and Time of instument Activation or Expiration event
4564  /// sent as number of nanoseconds since Unix epoch.
4566  {
4567  const BlockLength offset = 1;
4568 
4569  return ordinary<Timestamp>(offset);
4570  }
4571 
4572  /// Returns size of entry body in bytes
4573  /// for given version of message template.
4576  {
4577  return 9;
4578  }
4579 
4580  /// Entity class name.
4582  static const Char* className()
4583  {
4584  return "InstrumentDefinitionOption55.EventsEntry";
4585  }
4586  };
4587 
4588  /// Repeating group containing EventsEntry entries.
4590 
4591  /// Number of FeedType entries.
4592  /// Entry of FeedTypesEntry repeating group.
4593  struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
4594  {
4595  /// Aliases base class type.
4597 
4598  /// Initializes blank instance.
4600 
4601  /// Initializes instance of given
4602  /// version over given memory block.
4603  FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
4604  : Base(data, length, version)
4605  {
4606  if (length < blockLength(version))
4607  throwBadBinaryData(className());
4608  }
4609 
4610  /// Describes a class of service for a given data feed. GBX-
4611  /// Real Book, GBI-Implied Book.
4613  {
4614  const BlockLength offset = 0;
4615  const BlockLength length = 3;
4616 
4617  return fixedStr<length>(offset);
4618  }
4619 
4620  /// Book depth.
4622  {
4623  const BlockLength offset = 3;
4624 
4625  return ordinary<Int8>(offset);
4626  }
4627 
4628  /// Returns size of entry body in bytes
4629  /// for given version of message template.
4632  {
4633  return 4;
4634  }
4635 
4636  /// Entity class name.
4638  static const Char* className()
4639  {
4640  return "InstrumentDefinitionOption55.FeedTypesEntry";
4641  }
4642  };
4643 
4644  /// Repeating group containing FeedTypesEntry entries.
4646 
4647  /// Number of InstrAttribType entries.
4648  /// Entry of InstAttribEntry repeating group.
4649  struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
4650  {
4651  /// Aliases base class type.
4653 
4654  /// Initializes blank instance.
4656 
4657  /// Initializes instance of given
4658  /// version over given memory block.
4659  InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
4660  : Base(data, length, version)
4661  {
4662  if (length < blockLength(version))
4663  throwBadBinaryData(className());
4664  }
4665 
4666  /// Instrument Eligibility Attributes.
4668  {
4669  return InstAttribType();
4670  }
4671 
4672  /// Bitmap field of 32 Boolean type Instrument eligibility
4673  /// flags.
4675  {
4676  const BlockLength offset = 0;
4677 
4678  return ordinary<InstAttribValue>(offset);
4679  }
4680 
4681  /// Returns size of entry body in bytes
4682  /// for given version of message template.
4685  {
4686  return 4;
4687  }
4688 
4689  /// Entity class name.
4691  static const Char* className()
4692  {
4693  return "InstrumentDefinitionOption55.InstAttribEntry";
4694  }
4695  };
4696 
4697  /// Repeating group containing InstAttribEntry entries.
4699 
4700  /// Number of entries.
4701  /// Entry of LotTypeRulesEntry repeating group.
4702  struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
4703  {
4704  /// Aliases base class type.
4706 
4707  /// Initializes blank instance.
4709 
4710  /// Initializes instance of given
4711  /// version over given memory block.
4712  LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
4713  : Base(data, length, version)
4714  {
4715  if (length < blockLength(version))
4716  throwBadBinaryData(className());
4717  }
4718 
4719  /// This tag is required to interpret the value in tag
4720  /// 1231-MinLotSize.
4721  Int8 lotType() const
4722  {
4723  const BlockLength offset = 0;
4724 
4725  return ordinary<Int8>(offset);
4726  }
4727 
4728  /// Minimum quantity accepted for order entry. If tag
4729  /// 1093-LotType=4, this value is the minimum quantity for
4730  /// order entry expressed in the applicable units, specified
4731  /// in tag 996-UnitOfMeasure, e.g. megawatts.
4732  bool minLotSize(Decimal& value) const
4733  {
4734  typedef NullDecimalQty Null;
4735 
4736  const BlockLength offset = 1;
4737 
4738  return decimal(value, offset, Null());
4739  }
4740 
4741  /// Returns size of entry body in bytes
4742  /// for given version of message template.
4745  {
4746  return 5;
4747  }
4748 
4749  /// Entity class name.
4751  static const Char* className()
4752  {
4753  return "InstrumentDefinitionOption55.LotTypeRulesEntry";
4754  }
4755  };
4756 
4757  /// Repeating group containing LotTypeRulesEntry entries.
4759 
4760  /// Number of underlying instruments.
4761  /// Entry of UnderlyingsEntry repeating group.
4762  struct ONIXS_CMEMDH_LTWT UnderlyingsEntry : BinaryGroupEntry<GroupSize::BlockLength>
4763  {
4764  /// Aliases base class type.
4766 
4767  /// Initializes blank instance.
4769 
4770  /// Initializes instance of given
4771  /// version over given memory block.
4772  UnderlyingsEntry(const void* data, EncodedLength length, SchemaVersion version)
4773  : Base(data, length, version)
4774  {
4775  if (length < blockLength(version))
4776  throwBadBinaryData(className());
4777  }
4778 
4779  /// Unique Instrument ID as qualified by the exchange per tag
4780  /// 305-UnderlyingSecurityIDSource.
4782  {
4783  const BlockLength offset = 0;
4784 
4785  return ordinary<Int32>(offset);
4786  }
4787 
4788  /// This value is always '8' for CME.
4790  {
4791  return SecurityIDSource();
4792  }
4793 
4794  /// Underlying Instrument Symbol (Contract Name).
4796  {
4797  const BlockLength offset = 4;
4798  const BlockLength length = 20;
4799 
4800  return fixedStr<length>(offset);
4801  }
4802 
4803  /// Returns size of entry body in bytes
4804  /// for given version of message template.
4807  {
4808  return 24;
4809  }
4810 
4811  /// Entity class name.
4813  static const Char* className()
4814  {
4815  return "InstrumentDefinitionOption55.UnderlyingsEntry";
4816  }
4817  };
4818 
4819  /// Repeating group containing UnderlyingsEntry entries.
4821 
4822  /// Number of related instruments group.
4823  /// Entry of RelatedInstrumentsEntry repeating group.
4825  {
4826  /// Aliases base class type.
4828 
4829  /// Initializes blank instance.
4831 
4832  /// Initializes instance of given
4833  /// version over given memory block.
4834  RelatedInstrumentsEntry(const void* data, EncodedLength length, SchemaVersion version)
4835  : Base(data, length, version)
4836  {
4837  if (length < blockLength(version))
4838  throwBadBinaryData(className());
4839  }
4840 
4841  /// Related Security ID.
4843  {
4844  const BlockLength offset = 0;
4845 
4846  return ordinary<Int32>(offset);
4847  }
4848 
4849  /// Related Security ID source.
4851  {
4852  return SecurityIDSource();
4853  }
4854 
4855  /// Related instrument Symbol.
4857  {
4858  const BlockLength offset = 4;
4859  const BlockLength length = 20;
4860 
4861  return fixedStr<length>(offset);
4862  }
4863 
4864  /// Returns size of entry body in bytes
4865  /// for given version of message template.
4868  {
4869  return 24;
4870  }
4871 
4872  /// Entity class name.
4874  static const Char* className()
4875  {
4876  return "InstrumentDefinitionOption55.RelatedInstrumentsEntry";
4877  }
4878  };
4879 
4880  /// Repeating group containing RelatedInstrumentsEntry entries.
4882 
4883  /// Initializes blank instance.
4885 
4886  /// Initializes instance over given memory block.
4888  : BinaryMessage(data, length)
4889  {
4890  assert(TemplateId == templateId());
4891 
4892  const SchemaVersion current = version();
4894 
4895  if (current < since)
4896  throwBadMessageVersion(className(), current, since);
4897 
4898  if (length < blockLength(version()))
4899  throwBadBinaryData(className());
4900  }
4901 
4902  /// Bitmap field of eight Boolean type indicators reflecting
4903  /// the end of updates for a given Globex event.
4905  {
4906  const BlockLength offset = 0;
4907 
4908  return ordinary<MatchEventIndicator>(offset);
4909  }
4910 
4911  /// Total number of instruments in the Replay loop. Used on
4912  /// Replay Feed only.
4914  {
4915  typedef NullUInt32 Null;
4916 
4917  const BlockLength offset = 1;
4918 
4919  return ordinary(value, offset, Null());
4920  }
4921 
4922  /// Last Security update action on Incremental feed, 'D' or
4923  /// 'M' is used when a mid-week deletion or modification (i.e.
4924  /// extension) occurs.
4926  {
4927  const BlockLength offset = 5;
4928 
4929  return enumeration<SecurityUpdateAction>(offset);
4930  }
4931 
4932  /// Timestamp of when the instrument was last added, modified
4933  /// or deleted.
4935  {
4936  const BlockLength offset = 6;
4937 
4938  return ordinary<Timestamp>(offset);
4939  }
4940 
4941  /// Identifies the current state of the instrument. The data
4942  /// is available in the Instrument Replay feed only.
4944  {
4945  typedef NullUInt8 Null;
4946 
4947  const BlockLength offset = 14;
4948 
4949  return enumeration<SecurityTradingStatus>(value, offset, Null());
4950  }
4951 
4952  /// The channel ID as defined in the XML Configuration file.
4953  Int16 applId() const
4954  {
4955  const BlockLength offset = 15;
4956 
4957  return ordinary<Int16>(offset);
4958  }
4959 
4960  /// Identifies the market segment, populated for all CME
4961  /// Globex instruments.
4963  {
4964  const BlockLength offset = 17;
4965 
4966  return ordinary<UInt8>(offset);
4967  }
4968 
4969  /// Indicates the product complex.
4971  {
4972  const BlockLength offset = 18;
4973 
4974  return ordinary<UInt8>(offset);
4975  }
4976 
4977  /// Exchange used to identify a security.
4979  {
4980  const BlockLength offset = 19;
4981  const BlockLength length = 4;
4982 
4983  return fixedStr<length>(offset);
4984  }
4985 
4986  /// Security Group Code.
4988  {
4989  const BlockLength offset = 23;
4990  const BlockLength length = 6;
4991 
4992  return fixedStr<length>(offset);
4993  }
4994 
4995  /// The underlying asset code also known as Product Code.
4996  StrRef asset() const
4997  {
4998  const BlockLength offset = 29;
4999  const BlockLength length = 6;
5000 
5001  return fixedStr<length>(offset);
5002  }
5003 
5004  /// Instrument Name or Symbol. Previously used as Instrument
5005  /// Group Code.
5006  StrRef symbol() const
5007  {
5008  const BlockLength offset = 35;
5009  const BlockLength length = 20;
5010 
5011  return fixedStr<length>(offset);
5012  }
5013 
5014  /// Unique Instrument ID.
5016  {
5017  const BlockLength offset = 55;
5018 
5019  return ordinary<Int32>(offset);
5020  }
5021 
5022  /// Identifies class or source of tag 48-SecurityID value.
5024  {
5025  return SecurityIDSource();
5026  }
5027 
5028  /// Security Type.
5030  {
5031  const BlockLength offset = 59;
5032  const BlockLength length = 6;
5033 
5034  return fixedStr<length>(offset);
5035  }
5036 
5037  /// ISO standard instrument categorization code.
5038  StrRef cfiCode() const
5039  {
5040  const BlockLength offset = 65;
5041  const BlockLength length = 6;
5042 
5043  return fixedStr<length>(offset);
5044  }
5045 
5046  /// Indicates whether an option instrument is a put or call.
5048  {
5049  const BlockLength offset = 71;
5050 
5051  return enumeration<PutOrCall>(offset);
5052  }
5053 
5054  /// This field provides the actual calendar date for contract
5055  /// maturity.
5057  {
5058  typedef NullMaturityMonthYear Null;
5059 
5060  const BlockLength offset = 72;
5061 
5062  return ordinary(value, offset, Null());
5063  }
5064 
5065  /// Identifies currency used for price.
5067  {
5068  const BlockLength offset = 77;
5069  const BlockLength length = 3;
5070 
5071  return fixedStr<length>(offset);
5072  }
5073 
5074  /// Strike Price for an option instrument.
5076  {
5077  typedef NullPRICE9 Null;
5078 
5079  const BlockLength offset = 80;
5080 
5081  return decimal(value, offset, Null());
5082  }
5083 
5084  /// Currency in which the StrikePrice is denominated.
5086  {
5087  const BlockLength offset = 88;
5088  const BlockLength length = 3;
5089 
5090  return fixedStr<length>(offset);
5091  }
5092 
5093  /// Identifies currency used for settlement, if different from
5094  /// trade price currency.
5096  {
5097  const BlockLength offset = 91;
5098  const BlockLength length = 3;
5099 
5100  return fixedStr<length>(offset);
5101  }
5102 
5103  /// Defines cabinet price for outright options products.
5105  {
5106  typedef NullPRICE9 Null;
5107 
5108  const BlockLength offset = 94;
5109 
5110  return decimal(value, offset, Null());
5111  }
5112 
5113  /// Matching algorithm.
5115  {
5116  const BlockLength offset = 102;
5117 
5118  return ordinary<CHAR>(offset);
5119  }
5120 
5121  /// The minimum trading volume for a security.
5123  {
5124  const BlockLength offset = 103;
5125 
5126  return ordinary<UInt32>(offset);
5127  }
5128 
5129  /// The maximum trading volume for a security.
5131  {
5132  const BlockLength offset = 107;
5133 
5134  return ordinary<UInt32>(offset);
5135  }
5136 
5137  /// Minimum constant tick for the instrument.
5139  {
5140  typedef NullPRICE9 Null;
5141 
5142  const BlockLength offset = 111;
5143 
5144  return decimal(value, offset, Null());
5145  }
5146 
5147  /// Monetary value equivalent to the minimum price fluctuation.
5149  {
5150  typedef NullPRICE9 Null;
5151 
5152  const BlockLength offset = 119;
5153 
5154  return decimal(value, offset, Null());
5155  }
5156 
5157  /// Contains the multiplier to convert the CME Globex display
5158  /// price to the conventional price.
5160  {
5161  const BlockLength offset = 127;
5162 
5163  return decimal<Decimal9>(offset);
5164  }
5165 
5166  /// VTT code referencing variable tick table.
5167  bool tickRule(Int8& value) const
5168  {
5169  typedef NullInt8 Null;
5170 
5171  const BlockLength offset = 135;
5172 
5173  return ordinary(value, offset, Null());
5174  }
5175 
5176  /// Price Denominator of Main Fraction.
5177  bool mainFraction(UInt8& value) const
5178  {
5179  typedef NullUInt8 Null;
5180 
5181  const BlockLength offset = 136;
5182 
5183  return ordinary(value, offset, Null());
5184  }
5185 
5186  /// Price Denominator of Sub Fraction.
5187  bool subFraction(UInt8& value) const
5188  {
5189  typedef NullUInt8 Null;
5190 
5191  const BlockLength offset = 137;
5192 
5193  return ordinary(value, offset, Null());
5194  }
5195 
5196  /// Number of decimals in fractional display price.
5198  {
5199  typedef NullUInt8 Null;
5200 
5201  const BlockLength offset = 138;
5202 
5203  return ordinary(value, offset, Null());
5204  }
5205 
5206  /// Unit of measure for the products' original contract size.
5207  /// This will be populated for all products listed on CME
5208  /// Globex.
5210  {
5211  const BlockLength offset = 139;
5212  const BlockLength length = 30;
5213 
5214  return fixedStr<length>(offset);
5215  }
5216 
5217  /// This field contains the contract size for each instrument.
5218  /// Used in combination with tag 996-UnitofMeasure.
5220  {
5221  typedef NullDecimal9 Null;
5222 
5223  const BlockLength offset = 169;
5224 
5225  return decimal(value, offset, Null());
5226  }
5227 
5228  /// Reference price - the most recently available Settlement
5229  /// whether it be Theoretical, Preliminary or a Final Settle
5230  /// of the session.
5232  {
5233  typedef NullPRICE9 Null;
5234 
5235  const BlockLength offset = 177;
5236 
5237  return decimal(value, offset, Null());
5238  }
5239 
5240  /// Bitmap field of eight Boolean type indicators representing
5241  /// settlement price type.
5243  {
5244  const BlockLength offset = 185;
5245 
5246  return ordinary<SettlPriceType>(offset);
5247  }
5248 
5249  /// The total cleared volume of instrument traded during the
5250  /// prior trading session.
5252  {
5253  typedef NullInt32 Null;
5254 
5255  const BlockLength offset = 186;
5256 
5257  return ordinary(value, offset, Null());
5258  }
5259 
5260  /// The total open interest for the market at the close of the
5261  /// prior trading session.
5263  {
5264  typedef NullInt32 Null;
5265 
5266  const BlockLength offset = 190;
5267 
5268  return ordinary(value, offset, Null());
5269  }
5270 
5271  /// Allowable low limit price for the trading day.
5273  {
5274  typedef NullPRICE9 Null;
5275 
5276  const BlockLength offset = 194;
5277 
5278  return decimal(value, offset, Null());
5279  }
5280 
5281  /// Allowable high limit price for the trading day.
5283  {
5284  typedef NullPRICE9 Null;
5285 
5286  const BlockLength offset = 202;
5287 
5288  return decimal(value, offset, Null());
5289  }
5290 
5291  /// User-defined instruments flag.
5293  {
5294  const BlockLength offset = 210;
5295 
5296  return ordinary<UserDefinedInstrument>(offset);
5297  }
5298 
5299  /// Indicates session date corresponding to the settlement
5300  /// price in tag 1150-TradingReferencePrice.
5302  {
5303  typedef NullLocalMktDate Null;
5304  typedef LocalMktDate FieldValue;
5305 
5306  const BlockLength offset = 211;
5307 
5308  FieldValue fieldValue;
5309 
5310  if (ordinary(fieldValue, offset, Null()))
5311  {
5312  value = localMktDateToTimestamp(fieldValue);
5313  return true;
5314  }
5315  return false;
5316  }
5317 
5318  /// External unique instrument ID.
5320  {
5321  typedef NullUInt64 Null;
5322 
5323  const BlockLength offset = 213;
5324  const SchemaVersion since = 10;
5325 
5326  return ordinary(value, offset, Null(), since);
5327  }
5328 
5329  /// Returns instance of Events repeating group.
5330  Events events() const
5331  {
5332  return groups().head<Events>();
5333  }
5334 
5335  /// Returns instance of FeedTypes repeating group.
5336  FeedTypes feedTypes() const
5337  {
5338  return groups().tail<Events>().head<FeedTypes>();
5339  }
5340 
5341  /// Returns instance of InstAttrib repeating group.
5342  InstAttrib instAttrib() const
5343  {
5344  return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
5345  }
5346 
5347  /// Returns instance of LotTypeRules repeating group.
5348  LotTypeRules lotTypeRules() const
5349  {
5350  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
5351  }
5352 
5353  /// Returns instance of Underlyings repeating group.
5354  Underlyings underlyings() const
5355  {
5356  return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().head<Underlyings>();
5357  }
5358 
5359  /// Returns instance of RelatedInstruments repeating group.
5360  RelatedInstruments relatedInstruments() const
5361  {
5362  return groups()
5363  .tail<Events>()
5364  .tail<FeedTypes>()
5365  .tail<InstAttrib>()
5366  .tail<LotTypeRules>()
5367  .tail<Underlyings>()
5368  .head<RelatedInstruments>();
5369  }
5370 
5371  /// Size of message body in bytes.
5374  {
5375  if (version >= 10)
5376  return 221;
5377 
5378  return 213;
5379  }
5380 
5381  /// Returns class name.
5383  static const Char* className()
5384  {
5385  return "InstrumentDefinitionOption55";
5386  }
5387 
5388  /// FIX message type.
5390  static StrRef fixType()
5391  {
5392  return toStrRef("d");
5393  }
5394 };
5395 
5396 /// MDIncrementalRefreshTradeSummary.
5398 {
5399  /// Message template ID from SBE schema.
5400  enum
5401  {
5402  TemplateId = 48
5403  };
5404 
5405  /// Number of Trade Summary entries.
5406  /// Entry of Entry repeating group.
5407  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
5408  {
5409  /// Aliases base class type.
5411 
5412  /// Initializes blank instance.
5413  Entry() {}
5414 
5415  /// Initializes instance of given
5416  /// version over given memory block.
5417  Entry(const void* data, EncodedLength length, SchemaVersion version)
5418  : Base(data, length, version)
5419  {
5420  if (length < blockLength(version))
5421  throwBadBinaryData(className());
5422  }
5423 
5424  /// Trade price.
5426  {
5427  const BlockLength offset = 0;
5428 
5429  return decimal<PRICE9>(offset);
5430  }
5431 
5432  /// Consolidated trade quantity.
5434  {
5435  const BlockLength offset = 8;
5436 
5437  return ordinary<Int32>(offset);
5438  }
5439 
5440  /// Security ID as defined by CME.
5442  {
5443  const BlockLength offset = 12;
5444 
5445  return ordinary<Int32>(offset);
5446  }
5447 
5448  /// Sequence number per instrument update.
5449  UInt32 rptSeq() const
5450  {
5451  const BlockLength offset = 16;
5452 
5453  return ordinary<UInt32>(offset);
5454  }
5455 
5456  /// The total number of real orders per instrument that
5457  /// participated in a match step within a match event.
5459  {
5460  const BlockLength offset = 20;
5461 
5462  return ordinary<Int32>(offset);
5463  }
5464 
5465  /// Indicates which side is the aggressor or if there is no
5466  /// aggressor.
5468  {
5469  typedef NullUInt8 Null;
5470 
5471  const BlockLength offset = 24;
5472 
5473  return enumeration<AggressorSide>(value, offset, Null());
5474  }
5475 
5476  /// Market Data update action.
5478  {
5479  const BlockLength offset = 25;
5480 
5481  return enumeration<UpdateAction>(offset);
5482  }
5483 
5484  /// Market Data entry type.
5486  {
5487  return EntryTypeTrade();
5488  }
5489 
5490  /// Market Data Trade entry ID.
5492  {
5493  typedef NullUInt32 Null;
5494 
5495  const BlockLength offset = 26;
5496 
5497  return ordinary(value, offset, Null());
5498  }
5499 
5500  /// Returns size of entry body in bytes
5501  /// for given version of message template.
5504  {
5505  return 30;
5506  }
5507 
5508  /// Entity class name.
5510  static const Char* className()
5511  {
5512  return "IncrementalRefreshTradeSummary48.Entry";
5513  }
5514  };
5515 
5516  /// Repeating group containing Entry entries.
5518 
5519  /// Number of OrderID entries.
5520  /// Entry of OrderIDEntry repeating group.
5521  struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
5522  {
5523  /// Aliases base class type.
5525 
5526  /// Initializes blank instance.
5528 
5529  /// Initializes instance of given
5530  /// version over given memory block.
5531  OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
5532  : Base(data, length, version)
5533  {
5534  if (length < blockLength(version))
5535  throwBadBinaryData(className());
5536  }
5537 
5538  /// Unique order identifier as assigned by the exchange.
5539  UInt64 orderId() const
5540  {
5541  const BlockLength offset = 0;
5542 
5543  return ordinary<UInt64>(offset);
5544  }
5545 
5546  /// Quantity bought or sold on this last fill.
5547  Int32 lastQty() const
5548  {
5549  const BlockLength offset = 8;
5550 
5551  return ordinary<Int32>(offset);
5552  }
5553 
5554  /// Returns size of entry body in bytes
5555  /// for given version of message template.
5558  {
5559  return 12;
5560  }
5561 
5562  /// Entity class name.
5564  static const Char* className()
5565  {
5566  return "IncrementalRefreshTradeSummary48.OrderIDEntry";
5567  }
5568  };
5569 
5570  /// Repeating group containing OrderIDEntry entries.
5572 
5573  /// Initializes blank instance.
5575 
5576  /// Initializes instance over given memory block.
5578  : BinaryMessage(data, length)
5579  {
5580  assert(TemplateId == templateId());
5581 
5582  const SchemaVersion current = version();
5584 
5585  if (current < since)
5586  throwBadMessageVersion(className(), current, since);
5587 
5588  if (length < blockLength(version()))
5589  throwBadBinaryData(className());
5590  }
5591 
5592  /// Start of event processing time in number of nanoseconds
5593  /// since Unix epoch.
5595  {
5596  const BlockLength offset = 0;
5597 
5598  return ordinary<Timestamp>(offset);
5599  }
5600 
5601  /// Bitmap field of eight Boolean type indicators reflecting
5602  /// the end of updates for a given Globex event.
5604  {
5605  const BlockLength offset = 8;
5606 
5607  return ordinary<MatchEventIndicator>(offset);
5608  }
5609 
5610  /// Returns instance of Entries repeating group.
5611  Entries entries() const
5612  {
5613  return groups().head<Entries>();
5614  }
5615 
5616  /// Returns instance of OrderIDEntries repeating group.
5617  OrderIDEntries orderIdEntries() const
5618  {
5619  return groups().tail<Entries>().head<OrderIDEntries>();
5620  }
5621 
5622  /// Size of message body in bytes.
5625  {
5626  return 9;
5627  }
5628 
5629  /// Returns class name.
5631  static const Char* className()
5632  {
5633  return "IncrementalRefreshTradeSummary48";
5634  }
5635 
5636  /// FIX message type.
5638  static StrRef fixType()
5639  {
5640  return toStrRef("X");
5641  }
5642 };
5643 
5644 /// MDIncrementalRefreshOrderBook.
5646 {
5647  /// Message template ID from SBE schema.
5648  enum
5649  {
5650  TemplateId = 47
5651  };
5652 
5653  /// Number of entries in Market Data message.
5654  /// Entry of Entry repeating group.
5655  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
5656  {
5657  /// Aliases base class type.
5659 
5660  /// Initializes blank instance.
5661  Entry() {}
5662 
5663  /// Initializes instance of given
5664  /// version over given memory block.
5665  Entry(const void* data, EncodedLength length, SchemaVersion version)
5666  : Base(data, length, version)
5667  {
5668  if (length < blockLength(version))
5669  throwBadBinaryData(className());
5670  }
5671 
5672  /// Order ID.
5673  bool orderId(UInt64& value) const
5674  {
5675  typedef NullUInt64 Null;
5676 
5677  const BlockLength offset = 0;
5678 
5679  return ordinary(value, offset, Null());
5680  }
5681 
5682  /// Order priority for execution on the order book.
5684  {
5685  typedef NullUInt64 Null;
5686 
5687  const BlockLength offset = 8;
5688 
5689  return ordinary(value, offset, Null());
5690  }
5691 
5692  /// Order price.
5693  bool entryPx(Decimal& value) const
5694  {
5695  typedef NullPRICE9 Null;
5696 
5697  const BlockLength offset = 16;
5698 
5699  return decimal(value, offset, Null());
5700  }
5701 
5702  /// Visible order qty.
5703  bool displayQty(Int32& value) const
5704  {
5705  typedef NullInt32 Null;
5706 
5707  const BlockLength offset = 24;
5708 
5709  return ordinary(value, offset, Null());
5710  }
5711 
5712  /// Security ID.
5714  {
5715  const BlockLength offset = 28;
5716 
5717  return ordinary<Int32>(offset);
5718  }
5719 
5720  /// Order book update action to be applied to the order
5721  /// referenced by OrderID.
5723  {
5724  const BlockLength offset = 32;
5725 
5726  return enumeration<UpdateAction>(offset);
5727  }
5728 
5729  /// Market Data entry type.
5731  {
5732  const BlockLength offset = 33;
5733 
5734  return enumeration<EntryTypeBook>(offset);
5735  }
5736 
5737  /// Returns size of entry body in bytes
5738  /// for given version of message template.
5741  {
5742  return 34;
5743  }
5744 
5745  /// Entity class name.
5747  static const Char* className()
5748  {
5749  return "IncrementalRefreshOrderBook47.Entry";
5750  }
5751  };
5752 
5753  /// Repeating group containing Entry entries.
5755 
5756  /// Initializes blank instance.
5758 
5759  /// Initializes instance over given memory block.
5761  : BinaryMessage(data, length)
5762  {
5763  assert(TemplateId == templateId());
5764 
5765  const SchemaVersion current = version();
5767 
5768  if (current < since)
5769  throwBadMessageVersion(className(), current, since);
5770 
5771  if (length < blockLength(version()))
5772  throwBadBinaryData(className());
5773  }
5774 
5775  /// Start of event processing time in number of nanoseconds
5776  /// since Unix epoch.
5778  {
5779  const BlockLength offset = 0;
5780 
5781  return ordinary<Timestamp>(offset);
5782  }
5783 
5784  /// Bitmap field of eight Boolean type indicators reflecting
5785  /// the end of updates for a given Globex event.
5787  {
5788  const BlockLength offset = 8;
5789 
5790  return ordinary<MatchEventIndicator>(offset);
5791  }
5792 
5793  /// Returns instance of Entries repeating group.
5794  Entries entries() const
5795  {
5796  return groups().head<Entries>();
5797  }
5798 
5799  /// Size of message body in bytes.
5802  {
5803  return 9;
5804  }
5805 
5806  /// Returns class name.
5808  static const Char* className()
5809  {
5810  return "IncrementalRefreshOrderBook47";
5811  }
5812 
5813  /// FIX message type.
5815  static StrRef fixType()
5816  {
5817  return toStrRef("X");
5818  }
5819 };
5820 
5821 /// SnapshotFullRefreshOrderBook.
5823 {
5824  /// Message template ID from SBE schema.
5825  enum
5826  {
5827  TemplateId = 53
5828  };
5829 
5830  /// Number of entries in Market Data message.
5831  /// Entry of Entry repeating group.
5832  struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
5833  {
5834  /// Aliases base class type.
5836 
5837  /// Initializes blank instance.
5838  Entry() {}
5839 
5840  /// Initializes instance of given
5841  /// version over given memory block.
5842  Entry(const void* data, EncodedLength length, SchemaVersion version)
5843  : Base(data, length, version)
5844  {
5845  if (length < blockLength(version))
5846  throwBadBinaryData(className());
5847  }
5848 
5849  /// Unique Order ID.
5850  UInt64 orderId() const
5851  {
5852  const BlockLength offset = 0;
5853 
5854  return ordinary<UInt64>(offset);
5855  }
5856 
5857  /// Order priority for execution on the order book.
5859  {
5860  typedef NullUInt64 Null;
5861 
5862  const BlockLength offset = 8;
5863 
5864  return ordinary(value, offset, Null());
5865  }
5866 
5867  /// Order Price.
5869  {
5870  const BlockLength offset = 16;
5871 
5872  return decimal<PRICE9>(offset);
5873  }
5874 
5875  /// Visible order qty.
5877  {
5878  const BlockLength offset = 24;
5879 
5880  return ordinary<Int32>(offset);
5881  }
5882 
5883  /// Market Data entry type.
5885  {
5886  const BlockLength offset = 28;
5887 
5888  return enumeration<EntryTypeBook>(offset);
5889  }
5890 
5891  /// Returns size of entry body in bytes
5892  /// for given version of message template.
5895  {
5896  return 29;
5897  }
5898 
5899  /// Entity class name.
5901  static const Char* className()
5902  {
5903  return "SnapshotFullRefreshOrderBook53.Entry";
5904  }
5905  };
5906 
5907  /// Repeating group containing Entry entries.
5909 
5910  /// Initializes blank instance.
5912 
5913  /// Initializes instance over given memory block.
5915  : BinaryMessage(data, length)
5916  {
5917  assert(TemplateId == templateId());
5918 
5919  const SchemaVersion current = version();
5921 
5922  if (current < since)
5923  throwBadMessageVersion(className(), current, since);
5924 
5925  if (length < blockLength(version()))
5926  throwBadBinaryData(className());
5927  }
5928 
5929  /// Sequence number of the last Incremental feed packet
5930  /// processed. This value is used to synchronize the snapshot
5931  /// loop with the real-time feed.
5933  {
5934  const BlockLength offset = 0;
5935 
5936  return ordinary<UInt32>(offset);
5937  }
5938 
5939  /// Total number of instruments in the replayed loop.
5941  {
5942  const BlockLength offset = 4;
5943 
5944  return ordinary<UInt32>(offset);
5945  }
5946 
5947  /// Security ID.
5949  {
5950  const BlockLength offset = 8;
5951 
5952  return ordinary<Int32>(offset);
5953  }
5954 
5955  /// Total number of packets that constitutes a single
5956  /// instrument order book.
5957  UInt32 chunks() const
5958  {
5959  const BlockLength offset = 12;
5960 
5961  return ordinary<UInt32>(offset);
5962  }
5963 
5964  /// Chunk sequence.
5966  {
5967  const BlockLength offset = 16;
5968 
5969  return ordinary<UInt32>(offset);
5970  }
5971 
5972  /// Timestamp of the last event security participated in, sent
5973  /// as number of nanoseconds since Unix epoch.
5975  {
5976  const BlockLength offset = 20;
5977 
5978  return ordinary<Timestamp>(offset);
5979  }
5980 
5981  /// Returns instance of Entries repeating group.
5982  Entries entries() const
5983  {
5984  return groups().head<Entries>();
5985  }
5986 
5987  /// Size of message body in bytes.
5990  {
5991  return 28;
5992  }
5993 
5994  /// Returns class name.
5996  static const Char* className()
5997  {
5998  return "SnapshotFullRefreshOrderBook53";
5999  }
6000 
6001  /// FIX message type.
6003  static StrRef fixType()
6004  {
6005  return toStrRef("W");
6006  }
6007 };
6008 
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:935
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3761
Decimal displayFactor() const
Contains the multiplier to convert the CME Globex display price to the conventional price...
Definition: Messages.h:5159
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:156
StrRef currency() const
Identifies currency used for price.
Definition: Messages.h:5066
UpdateActionNew updateAction() const
Market Data entry update action.
Definition: Messages.h:3652
RelatedSymEntry()
Initializes blank instance.
Definition: Messages.h:4378
MDIncrementalRefreshSessionStatistics.
Definition: Messages.h:3748
bool decayQuantity(Int32 &value) const
Indicates the quantity that a contract will decay daily by once the decay start date is reached...
Definition: Messages.h:1950
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:4003
static const Char * className()
Returns class name.
Definition: Messages.h:4057
static const Char * className()
Returns class name.
Definition: Messages.h:5808
StrRef underlyingSymbol() const
Underlying Instrument Symbol (Contract Name).
Definition: Messages.h:4795
static const Char * className()
Returns class name.
Definition: Messages.h:3734
bool tickRule(Int8 &value) const
VTT code referencing variable tick table.
Definition: Messages.h:5167
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3940
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3838
BinaryGroup< InstAttribEntry, GroupSize, MessageSize > InstAttrib
Repeating group containing InstAttribEntry entries.
Definition: Messages.h:1526
static const Char * className()
Returns class name.
Definition: Messages.h:3370
Int8 lotType() const
This tag is required to interpret the value in tag 1231-MinLotSize.
Definition: Messages.h:4721
bool totNumReports(UInt32 &value) const
Total number of instruments in the Replay loop.
Definition: Messages.h:1618
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:3074
QuoteRequest39()
Initializes blank instance.
Definition: Messages.h:4454
UInt32 minTradeVol() const
The minimum trading volume for a security.
Definition: Messages.h:2657
UInt32 minTradeVol() const
The minimum trading volume for a security.
Definition: Messages.h:5122
AdminHeartbeat410(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1317
bool minLotSize(Decimal &value) const
Minimum quantity accepted for order entry.
Definition: Messages.h:237
static const Char * className()
Returns class name.
Definition: Messages.h:5383
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:897
UInt16 LocalMktDate
LocalMktDate type.
Definition: Fields.h:68
RelatedSymEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4382
EntryTypeBook::Enum entryType() const
Market Data entry type.
Definition: Messages.h:3186
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3108
bool referenceId(UInt8 &value) const
Reference to corresponding Price and Security ID, sequence of MD entry in the message.
Definition: Messages.h:3275
bool flowScheduleType(Int8 &value) const
The schedule according to which the electricity is delivered in a physical contract, or priced in a financial contract.
Definition: Messages.h:2017
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:3892
static const Char * className()
Returns class name.
Definition: Messages.h:5996
static const Char * className()
Entity class name.
Definition: Messages.h:2234
FeedTypesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2199
static BlockLength blockLength(SchemaVersion version)
Size of message body in bytes.
Definition: Messages.h:860
Events events() const
Returns instance of Events repeating group.
Definition: Messages.h:5330
AdminLogin15()
Initializes blank instance.
Definition: Messages.h:1076
Int32 Int32
int32.
Definition: Fields.h:60
BlockLength blockLength() const
Length of the message body ( block of fixed-length fields).
StrRef feedType() const
Describes a class of service for a given data feed.
Definition: Messages.h:2208
bool aggressorSide(AggressorSide::Enum &value) const
Indicates which side is the aggressor or if there is no aggressor.
Definition: Messages.h:5467
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current trading state of the instrument.
Definition: Messages.h:4294
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:3342
bool highLimitPrice(Decimal &value) const
Upper price threshold for the instrument.
Definition: Messages.h:3604
bool instrumentGUId(UInt64 &value) const
External unique instrument ID.
Definition: Messages.h:5319
static const Char * className()
Returns class name.
Definition: Messages.h:4514
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:3852
AdminLogout409(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1256
bool priceDisplayFormat(UInt8 &value) const
Number of Decimals in Displayed Price.
Definition: Messages.h:510
EventsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4548
UInt32 maxTradeVol() const
The maximum trading volume for a security.
Definition: Messages.h:2665
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1223
static const Char * className()
Returns class name.
Definition: Messages.h:4348
InstAttribValue type.
Definition: Fields.h:714
Int8 lotType() const
This tag is required to interpret the value in tag 1231-MinLotSize.
Definition: Messages.h:225
bool tradingReferencePrice(Decimal &value) const
Reference price - the most recently available Settlement whether it be Theoretical, Preliminary or a Final Settle of the session.
Definition: Messages.h:2734
StrRef securityGroup() const
Security Group Code.
Definition: Messages.h:368
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3296
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current state of the instrument.
Definition: Messages.h:1649
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4827
SettlPriceType settlPriceType() const
Bitmap field of eight Boolean type indicators representing settlement price type. ...
Definition: Messages.h:4169
BinaryGroup< OrderIDEntry, GroupSize8Byte, MessageSize > OrderIDEntries
Repeating group containing OrderIDEntry entries.
Definition: Messages.h:3310
BinaryGroup< FeedTypesEntry, GroupSize, MessageSize > FeedTypes
Repeating group containing FeedTypesEntry entries.
Definition: Messages.h:2241
SnapshotFullRefreshOrderBook.
Definition: Messages.h:5822
UInt64 orderId() const
Unique order identifier as assigned by the exchange.
Definition: Messages.h:5539
bool tradingReferencePrice(Decimal &value) const
Trading Reference Price.
Definition: Messages.h:542
CHAR matchAlgorithm() const
Matching algorithm.
Definition: Messages.h:5114
static const Char * className()
Returns class name.
Definition: Messages.h:1053
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2361
MDIncrementalRefreshBook.
Definition: Messages.h:3095
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:2171
bool subFraction(UInt8 &value) const
Price Denominator of Sub Fraction.
Definition: Messages.h:5187
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:4507
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:3810
FeedTypes feedTypes() const
Returns instance of FeedTypes repeating group.
Definition: Messages.h:841
bool tickRule(Int8 &value) const
Tick Rule.
Definition: Messages.h:2713
Number of entries in Market Data message.
Definition: Messages.h:3930
BinaryGroup< EventsEntry, GroupSize, MessageSize > Events
Repeating group containing EventsEntry entries.
Definition: Messages.h:1417
bool highLimitPrice(Decimal &value) const
Allowable high limit price for the trading day.
Definition: Messages.h:2775
StrRef securityType() const
Security Type.
Definition: Messages.h:2594
StrRef symbol() const
Instrument Name or Symbol. Previously used as Group Code.
Definition: Messages.h:2570
StrRef cfiCode() const
ISO standard instrument categorization code.
Definition: Messages.h:418
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:5624
StrRef symbol() const
Instrument Name or Symbol.
Definition: Messages.h:5006
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1046
UpdateTypeNew updateAction() const
Market Data update action.
Definition: Messages.h:912
StrRef marketSet() const
Market Set defines the bilateral relationship and Self Match Prevention configuration for eligible ma...
Definition: Messages.h:2866
EventsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1376
BinaryGroup< EventsEntry, GroupSize, MessageSize > Events
Repeating group containing EventsEntry entries.
Definition: Messages.h:4589
InstAttribValue instAttribValue() const
Bitmap field of 32 Boolean type Instrument eligibility flags.
Definition: Messages.h:4674
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5665
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:5517
static StrRef fixType()
FIX message type.
Definition: Messages.h:3913
SecurityStatus30(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2964
UserDefinedInstrument userDefinedInstrument() const
User-defined instruments flag.
Definition: Messages.h:2641
AdminLogin15(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1079
StrRef currency() const
Identifies currency used for price.
Definition: Messages.h:1763
UInt32 lastMsgSeqNumProcessed() const
Sequence number of the last Incremental feed packet processed.
Definition: Messages.h:5932
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4375
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1480
StrRef marketSet() const
Market Set defines the bilateral relationship and Self Match Prevention configuration for eligible ma...
Definition: Messages.h:815
UInt8 underlyingProduct() const
Indicates the product complex.
Definition: Messages.h:4970
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:1459
static const Char * className()
Entity class name.
Definition: Messages.h:195
BinaryGroup< InstAttribEntry, GroupSize, MessageSize > InstAttrib
Repeating group containing InstAttribEntry entries.
Definition: Messages.h:2294
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4596
bool entrySize(Int32 &value) const
Indicative Opening Quantity.
Definition: Messages.h:3826
StrRef securityType() const
Security Type.
Definition: Messages.h:5029
Number of entries in Market Data message.
Definition: Messages.h:3105
UInt32 UInt32
uInt32.
Definition: Fields.h:192
static const Char * className()
Entity class name.
Definition: Messages.h:4194
StrRef securityGroup() const
Security Group Code.
Definition: Messages.h:2552
bool maturityMonthYear(MaturityMonthYear &value) const
This field provides the actual calendar date for contract maturity.
Definition: Messages.h:5056
static const Char * className()
Returns class name.
Definition: Messages.h:1003
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1369
UInt8 priceLevel() const
Aggregate book level.
Definition: Messages.h:3170
AdminHeartbeat12(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1029
InstAttribEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2255
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:1403
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:5786
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:3540
static const Char * className()
Returns class name.
Definition: Messages.h:2110
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2248
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:949
StrRef asset() const
The underlying asset code also known as Product Code.
Definition: Messages.h:4996
StrRef securityExchange() const
Exchange used to identify a security.
Definition: Messages.h:4978
Number of repeating InstrAttribType entries.
Definition: Messages.h:153
MatchEventIndicator type.
Definition: Fields.h:881
Null values definition for optional PRICE9 field.
Definition: Composites.h:195
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3404
SnapshotFullRefresh52(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:4207
bool instrumentGUId(UInt64 &value) const
External unique instrument ID.
Definition: Messages.h:2876
bool decayStartDate(Timestamp &value) const
Indicates the date at which a decaying contract will begin to decay.
Definition: Messages.h:1961
bool instrumentGUId(UInt64 &value) const
External unique instrument ID.
Definition: Messages.h:2064
IncrementalRefreshSessionStatistics51(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:3858
bool minLotSize(Decimal &value) const
Minimum quantity accepted for order entry.
Definition: Messages.h:2328
Null values definition for optional Decimal9 field.
Definition: Composites.h:34
Decimal decimal(Lengthoffset) const
Returns value of a field by its offset converted into a decimal.
OrderIDEntries orderIdEntries() const
Returns instance of OrderIDEntries repeating group.
Definition: Messages.h:3356
Represents time point without time-zone information.
Definition: Time.h:387
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:3350
static const Char * className()
Returns class name.
Definition: Messages.h:1342
StrRef feedType() const
Describes a class of service for a given data feed.
Definition: Messages.h:116
bool datedDate(Timestamp &value) const
Dated Date.
Definition: Messages.h:630
UInt8 underlyingProduct() const
Indicates the product complex.
Definition: Messages.h:351
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4631
Int16 applId() const
MD channel ID as defined in the XML Configuration file.
Definition: Messages.h:334
static const Char * className()
Entity class name.
Definition: Messages.h:2287
static const Char * className()
Entity class name.
Definition: Messages.h:142
Value ordinary(Lengthoffset) const
Returns value of a field by its offset.
Definition: BinaryMessage.h:53
IntegralConstant< Char, 'e'> EntryTypeVol
MDEntryTypeVol.
Definition: Fields.h:85
static StrRef fixType()
FIX message type.
Definition: Messages.h:1237
UInt32 chunks() const
Total number of packets that constitutes a single instrument order book.
Definition: Messages.h:5957
SnapshotFullRefresh52()
Initializes blank instance.
Definition: Messages.h:4204
EntryTypeBook::Enum entryType() const
Market Data entry type.
Definition: Messages.h:5884
Int16 applId() const
The channel ID as defined in the XML Configuration file.
Definition: Messages.h:2516
EventsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:52
StrRef unitOfMeasure() const
Unit of measure for the products&#39; original contract size.
Definition: Messages.h:5209
SecurityUpdateAction::Enum securityUpdateAction() const
Last Security update action on Incremental feed, &#39;D&#39; or &#39;M&#39; is used when a mid-week deletion or modif...
Definition: Messages.h:4925
static const Char * className()
Entity class name.
Definition: Messages.h:3996
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:2280
Timestamp transactTime() const
Timestamp of the last event security participated in, sent as number of nanoseconds since Unix epoch...
Definition: Messages.h:5974
static const Char * className()
Entity class name.
Definition: Messages.h:4638
StrRef settlCurrency() const
Identifies currency used for settlement, if different from trading currency.
Definition: Messages.h:1773
IntegralConstant< Int8, 24 > InstAttribType
Eligibility.
Definition: Fields.h:54
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:3555
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1164
UInt32 minTradeVol() const
The minimum trading volume for a security.
Definition: Messages.h:1790
SnapshotFullRefreshOrderBook53(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:5914
Int16 applId() const
The channel ID as defined in the XML Configuration file.
Definition: Messages.h:1659
StrRef asset() const
Product Code within Security Group specified.
Definition: Messages.h:2998
bool unitOfMeasureQty(Decimal &value) const
This field contains the contract size for each instrument.
Definition: Messages.h:532
MessageSize BlockLength
Length of message body representing a block of fixed-length fields.
LotTypeRules lotTypeRules() const
Returns instance of LotTypeRules repeating group.
Definition: Messages.h:2093
static StrRef fixType()
FIX message type.
Definition: Messages.h:4521
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:3224
StrRef securityExchange() const
Exchange used to identify a security.
Definition: Messages.h:359
bool openCloseSettlFlag(OpenCloseSettlFlag::Enum &value) const
Flag describing IOP and Open Price entries.
Definition: Messages.h:3800
bool tradeEntryId(UInt32 &value) const
Market Data Trade entry ID.
Definition: Messages.h:5491
GroupSize::BlockLength EncodedLength
Represents the length of binary data occupied by the given group entry.
UInt8 marketSegmentId() const
Identifies the market segment, populated for all CME Globex instruments.
Definition: Messages.h:4962
Timestamp eventTime() const
Date and time of instument Activation or Expiration event sent as number of nanoseconds since Unix ep...
Definition: Messages.h:2161
IntegralConstant< Char, 'J'> EntryTypeChannelReset
Channel Reset message entry type.
Definition: Fields.h:76
SecurityIDSource securityIdSource() const
Identifies class or source of tag 48-SecurityID value.
Definition: Messages.h:5023
static const Char * className()
Entity class name.
Definition: Messages.h:2347
StrRef relatedSymbol() const
Related instrument Symbol.
Definition: Messages.h:4856
bool clearedVolume(Int32 &value) const
The total cleared volume of instrument traded during the prior trading session.
Definition: Messages.h:2765
static const Char * className()
Returns class name.
Definition: Messages.h:1111
SecurityUpdateAction::Enum securityUpdateAction() const
Last Security update action on Incremental feed, &#39;D&#39; or &#39;M&#39; is used when a mid-week deletion or modif...
Definition: Messages.h:1630
EventType::Enum eventType() const
Code to represent the type of event.
Definition: Messages.h:4556
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:3037
bool orderId(UInt64 &value) const
Order ID.
Definition: Messages.h:5673
bool priceDisplayFormat(UInt8 &value) const
Number of decimals in fractional display price.
Definition: Messages.h:1844
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1335
StrRef asset() const
The underlying asset code also known as Product Code.
Definition: Messages.h:2561
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:5794
UserDefinedInstrument userDefinedInstrument() const
User-defined instruments flag.
Definition: Messages.h:2037
UserDefinedInstrument userDefinedInstrument() const
User-defined Instrument flag.
Definition: Messages.h:795
Timestamp lastUpdateTime() const
Timestamp of when the instrument was last added, modified or deleted.
Definition: Messages.h:2497
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:4324
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:5611
ChannelReset4()
Initializes blank instance.
Definition: Messages.h:952
StrRef securityType() const
Security Type.
Definition: Messages.h:1734
StrRef symbol() const
Instrument Name or Symbol.
Definition: Messages.h:4390
bool mainFraction(UInt8 &value) const
Price Denominator of Main Fraction.
Definition: Messages.h:2805
BinaryGroup< RelatedSymEntry, GroupSize, MessageSize > RelatedSym
Repeating group containing RelatedSymEntry entries.
Definition: Messages.h:4451
bool orderPriority(UInt64 &value) const
Order priority for execution on the order book.
Definition: Messages.h:3254
bool minPriceIncrementAmount(Decimal &value) const
Monetary value equivalent to the minimum price fluctuation.
Definition: Messages.h:2027
bool issueDate(Timestamp &value) const
Issue Date.
Definition: Messages.h:612
MDIncrementalRefreshDailyStatistics.
Definition: Messages.h:3384
bool subFraction(UInt8 &value) const
Price Denominator of Sub Fraction.
Definition: Messages.h:1834
bool legPrice(Decimal &value) const
Price for the future leg of a UDS Covered instrument.
Definition: Messages.h:2407
InstAttribType instAttribType() const
Instrument eligibility attributes.
Definition: Messages.h:1495
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5842
Timestamp eventTime() const
Date and Time of instument Activation or Expiration event sent as number of nanoseconds since Unix ep...
Definition: Messages.h:4565
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4867
Indicates the number of repeating symbols specified.
Definition: Messages.h:4372
bool clearedVolume(Int32 &value) const
The total cleared volume of instrument traded during the prior trading session.
Definition: Messages.h:5251
bool orderQty(Int32 &value) const
Quantity requested.
Definition: Messages.h:4407
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:2430
StrRef riskSet() const
Risk Set identifies the list of instruments sharing credit limits set up.
Definition: Messages.h:804
bool minLotSize(Decimal &value) const
Minimum quantity accepted for order entry.
Definition: Messages.h:4732
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:3972
Int32 securityId() const
Unique instrument ID.
Definition: Messages.h:395
static const Char * className()
Returns class name.
Definition: Messages.h:3081
bool numberOfOrders(Int32 &value) const
In Book entry - aggregate number of orders at given price level.
Definition: Messages.h:3160
bool minPriceIncrement(Decimal &value) const
Minimum constant tick for the instrument, sent only if instrument is non-VTT (Variable Tick table) el...
Definition: Messages.h:471
AdminLogin408(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1197
BinaryGroup< EventsEntry, GroupSize, MessageSize > Events
Repeating group containing EventsEntry entries.
Definition: Messages.h:93
FeedTypesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:107
InstrumentDefinitionFixedIncome57(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:269
Int32 displayQty() const
Visible order qty.
Definition: Messages.h:5876
static const Char * className()
Returns class name.
Definition: Messages.h:5631
static const Char * className()
Entity class name.
Definition: Messages.h:4751
#define ONIXS_CMEMDH_LTWT
Definition: Bootstrap.h:46
static const Char * className()
Entity class name.
Definition: Messages.h:86
static const Char * className()
Entity class name.
Definition: Messages.h:4813
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:5658
StrRef settlCurrency() const
Identifies currency used for settlement, if different from trade price currency.
Definition: Messages.h:5095
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4765
SecurityIDSource securityIdSource() const
Identifies class or source of Tag 48-SecurityID value.
Definition: Messages.h:403
bool mainFraction(UInt8 &value) const
Price Denominator of Main Fraction.
Definition: Messages.h:1824
UInt32 rptSeq() const
Sequence number per instrument update.
Definition: Messages.h:5449
EventType::Enum eventType() const
Code to represent the type of event.
Definition: Messages.h:2152
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4187
InstAttribValue instAttribValue() const
Bitmap field of 32 Boolean type instrument eligibility flags.
Definition: Messages.h:1502
Legs legs() const
Returns instance of Legs repeating group.
Definition: Messages.h:2921
Char CHAR
char.
Definition: Fields.h:41
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:3875
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:591
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1424
Decimal minPriceIncrement() const
Minimum constant tick for the instrument, sent only if instrument is non-VTT (Variable Tick table) el...
Definition: Messages.h:1807
Decimal displayFactor() const
Contains the multiplier to convert the CME Globex display price to the conventional price...
Definition: Messages.h:482
bool lowLimitPrice(Decimal &value) const
Lower price threshold for the instrument.
Definition: Messages.h:4314
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current state of the instrument.
Definition: Messages.h:4943
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:45
static BlockLength blockLength(SchemaVersion version)
Size of message body in bytes.
Definition: Messages.h:5373
static StrRef fixType()
FIX message type.
Definition: Messages.h:6003
bool lowLimitPrice(Decimal &value) const
Allowable low limit price for the trading day.
Definition: Messages.h:2785
OrderIDEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5531
RelatedInstruments relatedInstruments() const
Returns instance of RelatedInstruments repeating group.
Definition: Messages.h:5360
AdminHeartbeat410()
Initializes blank instance.
Definition: Messages.h:1314
Null values definition for optional MaturityMonthYear field.
Definition: Composites.h:172
bool tradingReferenceDate(Timestamp &value) const
Indicates the date of trade session corresponding to a statistic entry.
Definition: Messages.h:4140
BinaryGroup< UnderlyingsEntry, GroupSize, MessageSize > Underlyings
Repeating group containing UnderlyingsEntry entries.
Definition: Messages.h:4820
bool tradeDate(Timestamp &value) const
Trade Session Date.
Definition: Messages.h:3018
BinaryGroup< LotTypeRulesEntry, GroupSize, MessageSize > LotTypeRules
Repeating group containing LotTypeRulesEntry entries.
Definition: Messages.h:4758
static const Char * className()
Entity class name.
Definition: Messages.h:5901
UInt32 rptSeq() const
MD Entry sequence number per instrument update.
Definition: Messages.h:3792
StrRef asset() const
The underlying asset code also known as Product Code.
Definition: Messages.h:1702
SettlPriceType settlPriceType() const
Bitmap field of eight Boolean type indicators representing settlement price type. ...
Definition: Messages.h:2745
static StrRef fixType()
FIX message type.
Definition: Messages.h:3741
StrRef text() const
Free format text string.
Definition: Messages.h:1154
Int32 underlyingSecurityId() const
Unique Instrument ID as qualified by the exchange per tag 305-UnderlyingSecurityIDSource.
Definition: Messages.h:4781
AdminHeartbeat12()
Initializes blank instance.
Definition: Messages.h:1026
StrRef feedType() const
Describes a class of service for a given data feed.
Definition: Messages.h:4612
bool side(Int8 &value) const
Side requested.
Definition: Messages.h:4425
bool tradingReferenceDate(Timestamp &value) const
Indicates session date corresponding to the settlement price in tag 1150-TradingReferencePrice.
Definition: Messages.h:2826
bool priceDisplayFormat(UInt8 &value) const
Number of decimals in fractional display price.
Definition: Messages.h:2693
HaltReason::Enum haltReason() const
Identifies the reason for the status change.
Definition: Messages.h:3056
bool minPriceIncrement(Decimal &value) const
Minimum constant tick for the instrument.
Definition: Messages.h:5138
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:3720
static StrRef fixType()
FIX message type.
Definition: Messages.h:5390
bool minPriceIncrement(Decimal &value) const
Minimum constant tick for the instrument, sent only if instrument is non-VTT (Variable Tick table) el...
Definition: Messages.h:2674
StrRef quoteReqId() const
Quote Request ID defined by the exchange.
Definition: Messages.h:4482
BinaryGroup< FeedTypesEntry, GroupSize, MessageSize > FeedTypes
Repeating group containing FeedTypesEntry entries.
Definition: Messages.h:149
AdminLogin408()
Initializes blank instance.
Definition: Messages.h:1194
bool securityId(Int32 &value) const
If this tag is present, 35=f message is sent for the instrument.
Definition: Messages.h:3008
UInt32 rptSeq() const
Market Data entry sequence number per instrument update.
Definition: Messages.h:3151
static const Char * className()
Entity class name.
Definition: Messages.h:4691
static const Char * className()
Entity class name.
Definition: Messages.h:3845
CHAR matchAlgorithm() const
Matching algorithm.
Definition: Messages.h:2649
OrderIDEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3238
PutOrCall::Enum putOrCall() const
Indicates whether an option instrument is a put or call.
Definition: Messages.h:5047
Entry()
Initializes blank instance.
Definition: Messages.h:900
Null values definition for optional DecimalQty field.
Definition: Composites.h:62
Encapsulates operations over SBE-encoded repeating group entry instance.
static const Char * className()
Entity class name.
Definition: Messages.h:3673
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4091
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:3727
bool tradingReferencePrice(Decimal &value) const
Reference price for prelisted instruments or the last calculated Settlement whether it be Theoretical...
Definition: Messages.h:1878
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:4201
StrRef securityGroup() const
Security Group Code.
Definition: Messages.h:1693
static SchemaVersion minimalTcpRecoveryVersion()
Returns minimal version of Global TCP Recovery Schema supported by the SDK.
Definition: SchemaTraits.h:49
bool minLotSize(Decimal &value) const
Minimum quantity accepted for order entry.
Definition: Messages.h:1560
IncrementalRefreshLimitsBanding50(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:3686
UInt8 UInt8
uInt8.
Definition: Fields.h:198
bool maturityMonthYear(MaturityMonthYear &value) const
This field provides the actual calendar date for contract maturity.
Definition: Messages.h:1753
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3589
IntegralConstant< Char, '2'> EntryTypeTrade
MDEntryTypeTrade.
Definition: Fields.h:82
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3115
StrRef unitOfMeasure() const
Unit of measure for the products&#39; original contract size.
Definition: Messages.h:522
Timestamp lastUpdateTime() const
Timestamp of when the instrument was last added, modified or deleted.
Definition: Messages.h:316
char Char
Character type alias.
Definition: String.h:36
Int32 securityId() const
Unique instrument ID.
Definition: Messages.h:1720
Int8 marketDepth() const
Identifies the depth of book.
Definition: Messages.h:2217
bool totNumReports(UInt32 &value) const
Total number of instruments in the Replay loop.
Definition: Messages.h:4913
IncrementalRefreshOrderBook47()
Initializes blank instance.
Definition: Messages.h:5757
Number of entries in Market Data message.
Definition: Messages.h:5832
StrRef securityExchange() const
Exchange used to identify a security.
Definition: Messages.h:1684
bool displayQty(Int32 &value) const
Visible qty of order.
Definition: Messages.h:3264
static StrRef fixType()
FIX message type.
Definition: Messages.h:3569
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:3476
CHAR matchAlgorithm() const
Matching Algorithm.
Definition: Messages.h:446
InstAttribValue instAttribValue() const
Bitmap field of 32 Boolean type instrument eligibility flags.
Definition: Messages.h:178
bool entrySize(Int32 &value) const
Market Data entry quantity.
Definition: Messages.h:4109
Number of entries in Market Data message.
Definition: Messages.h:894
MDIncrementalRefreshOrderBook.
Definition: Messages.h:5645
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4084
StrRef symbol() const
Instrument Name or Symbol.
Definition: Messages.h:386
MessageSize EncodedLength
Length of message binary data.
bool legOptionDelta(Decimal &value) const
Delta used to calculate the quantity of futures used to cover the option or option strategy...
Definition: Messages.h:2418
LotTypeRules lotTypeRules() const
Returns instance of LotTypeRules repeating group.
Definition: Messages.h:5348
AdminLogout16(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1137
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3494
EntryTypeChannelReset entryType() const
Market Data entry type.
Definition: Messages.h:918
UInt64 UInt64
uInt64.
Definition: Fields.h:195
bool value(Number &number, const MultiContainer &container, Tag tag)
Finds a tag-value entry in the given collection by the given tag and returns its value component tran...
static StrRef fixType()
FIX message type.
Definition: Messages.h:1349
InstAttribType instAttribType() const
Instrument eligibility attributes.
Definition: Messages.h:171
StrRef priceQuoteMethod() const
Price quotation method.
Definition: Messages.h:2844
FeedTypes feedTypes() const
Returns instance of FeedTypes repeating group.
Definition: Messages.h:5336
Int8 quoteType() const
Type of quote requested.
Definition: Messages.h:4417
SchemaVersion version() const
Version of message containing given repeating group instance.
BinaryGroup< LotTypeRulesEntry, GroupSize, MessageSize > LotTypeRules
Repeating group containing LotTypeRulesEntry entries.
Definition: Messages.h:263
Timestamp lastUpdateTime() const
Timestamp of when the instrument was last added, modified or deleted.
Definition: Messages.h:4934
BinaryGroup< LotTypeRulesEntry, GroupSize, MessageSize > LotTypeRules
Repeating group containing LotTypeRulesEntry entries.
Definition: Messages.h:1586
InstrumentDefinitionFuture54(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1592
Entry()
Initializes blank instance.
Definition: Messages.h:3111
static StrRef fixType()
FIX message type.
Definition: Messages.h:1178
ChannelReset4(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:955
Year, Month and Date.
Definition: Composites.h:87
LotTypeRules lotTypeRules() const
Returns instance of LotTypeRules repeating group.
Definition: Messages.h:853
Events events() const
Returns instance of Events repeating group.
Definition: Messages.h:835
InstAttribType instAttribType() const
Instrument Eligibility Attributes.
Definition: Messages.h:2263
Int32 entrySize() const
Consolidated trade quantity.
Definition: Messages.h:5433
static const Char * className()
Entity class name.
Definition: Messages.h:942
StrRef couponFrequencyUnit() const
Time unit associated with the frequency of the bond&#39;s coupon payment.
Definition: Messages.h:689
bool entryPx(Decimal &value) const
Order price.
Definition: Messages.h:5693
InstAttrib instAttrib() const
Returns instance of InstAttrib repeating group.
Definition: Messages.h:5342
StrRef securityExchange() const
Exchange used to identify a security.
Definition: Messages.h:2543
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:286
bool contractMultiplierUnit(Int8 &value) const
Indicates the type of multiplier being applied to the product.
Definition: Messages.h:2003
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:4050
static const Char * className()
Entity class name.
Definition: Messages.h:1519
static StrRef fixType()
FIX message type.
Definition: Messages.h:2945
StrRef securityAltId() const
Expanded instrument description.
Definition: Messages.h:753
Int32 securityId() const
Unique Instrument ID.
Definition: Messages.h:5015
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:4026
IncrementalRefreshSessionStatistics51()
Initializes blank instance.
Definition: Messages.h:3855
EventType::Enum eventType() const
Code to represent the type of event.
Definition: Messages.h:1384
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4652
static const Char * className()
Returns class name.
Definition: Messages.h:3906
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4575
FeedTypes feedTypes() const
Returns instance of FeedTypes repeating group.
Definition: Messages.h:2903
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3397
StrRef cfiCode() const
ISO standard instrument categorization code.
Definition: Messages.h:5038
SettlPriceType type.
Definition: Fields.h:952
Int16 Int16
int16.
Definition: Fields.h:57
Timestamp localMktDateToTimestamp(LocalMktDate days)
Converts days since epoch to Timestamp value.
Definition: Fields.h:1032
static StrRef fixType()
FIX message type.
Definition: Messages.h:5638
EntryTypeStatistics::Enum entryType() const
Market Data entry type.
Definition: Messages.h:3818
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:4035
bool contractMultiplier(Int32 &value) const
Number of deliverable units per instrument, e.g., peak days in maturity month or number of calendar d...
Definition: Messages.h:1991
InstrumentDefinitionSpread56(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2450
BinaryGroup< RelatedInstrumentsEntry, GroupSize, MessageSize > RelatedInstruments
Repeating group containing RelatedInstrumentsEntry entries.
Definition: Messages.h:4881
SecurityStatus30()
Initializes blank instance.
Definition: Messages.h:2961
UserDefinedInstrument userDefinedInstrument() const
User-defined instruments flag.
Definition: Messages.h:5292
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:4341
Int32 securityId() const
Security ID as defined by CME.
Definition: Messages.h:5441
StrRef securitySubType() const
Strategy type.
Definition: Messages.h:2632
bool openCloseSettlFlag(OpenCloseSettlFlag::Enum &value) const
Flag describing Open Price entry.
Definition: Messages.h:4158
IntegralConstant< Char, '8'> SecurityIDSource
SecurityIDSource.
Definition: Fields.h:116
void throwBadMessageVersion(const Char *, SchemaVersion, SchemaVersion)
Raises exception on bad message version.
Number of entries in Market Data message.
Definition: Messages.h:3586
Int16 applId() const
The channel ID as defined in the XML Configuration file.
Definition: Messages.h:4953
MessageTemplateId templateId() const
Template identifier of message being referenced.
bool minPriceIncrementAmount(Decimal &value) const
Monetary value equivalent to the minimum price fluctuation.
Definition: Messages.h:5148
QuoteRequest39(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:4457
bool priceRatio(Decimal &value) const
Used for price calculation in spread and leg pricing.
Definition: Messages.h:2703
bool orderPriority(UInt64 &value) const
Order priority for execution on the order book.
Definition: Messages.h:5858
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:5801
StrRef financialInstrumentFullName() const
Long name of the instrument.
Definition: Messages.h:742
Int32 securityId() const
Unique instrument ID.
Definition: Messages.h:2579
StrRef settlCurrency() const
Identifies currency used for settlement, if different from trade price currency.
Definition: Messages.h:437
Provides efficient way of accessing text-based values without copying content of the text being refer...
Definition: String.h:41
MDInstrumentDefinitionSpread.
Definition: Messages.h:2124
InstrumentDefinitionFixedIncome57()
Initializes blank instance.
Definition: Messages.h:266
MessageHeader::Version SchemaVersion
Aliases SBE-encoded data version type.
Definition: SchemaTraits.h:28
Number of entries in Market Data message.
Definition: Messages.h:3394
UInt8 marketSegmentId() const
Identifies the market segment, populated for all CME Globex instruments.
Definition: Messages.h:2525
static const Char * className()
Entity class name.
Definition: Messages.h:2178
static StrRef fixType()
FIX message type.
Definition: Messages.h:1298
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:3333
Number of repeating EventType entries.
Definition: Messages.h:42
BinaryGroup< LegsEntry, GroupSize, MessageSize > Legs
Repeating group containing LegsEntry entries.
Definition: Messages.h:2444
UInt8 marketSegmentId() const
Identifies the market segment for all CME Globex instruments.
Definition: Messages.h:343
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:249
bool underlyingProduct(UInt8 &value) const
Product complex.
Definition: Messages.h:2533
A real number with floating exponent.
Definition: Decimal.h:136
StrRef asset() const
The underlying asset code also known as Product Code.
Definition: Messages.h:377
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:5557
UInt32 rptSeq() const
MD Entry sequence number per instrument update.
Definition: Messages.h:3642
IntegralConstant< Char, 'g'> EntryTypeLimits
MDEntryTypeLimits.
Definition: Fields.h:79
LotTypeRulesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1540
bool openInterestQty(Int32 &value) const
The total open interest for the market at the close of the prior trading session. ...
Definition: Messages.h:2754
Entry()
Initializes blank instance.
Definition: Messages.h:4087
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:1939
#define ONIXS_CMEMDH_NAMESPACE_BEGIN
Definition: Bootstrap.h:67
static StrRef fixType()
FIX message type.
Definition: Messages.h:4064
SettlPriceType settlPriceType() const
Bitmap field of eight Boolean type indicators representing settlement price type. ...
Definition: Messages.h:1889
static SchemaVersion minimalVersion()
Returns minimal version supported by the SDK.
Definition: SchemaTraits.h:38
bool clearedVolume(Int32 &value) const
The total cleared volume of instrument traded during the prior trading session.
Definition: Messages.h:1909
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:100
Timestamp transactTime() const
Timestamp of the last event security participated in, sent as number of nanoseconds since Unix epoch...
Definition: Messages.h:4259
bool subFraction(UInt8 &value) const
Price Denominator of Sub Fraction.
Definition: Messages.h:500
bool entryPx(Decimal &value) const
Market Data entry price.
Definition: Messages.h:4099
bool couponFrequencyPeriod(UInt16 &value) const
Time unit multiplier for the frequency of the bond&#39;s coupon payment.
Definition: Messages.h:700
bool priceDisplayFormat(UInt8 &value) const
Number of decimals in fractional display price.
Definition: Messages.h:5197
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:135
IncrementalRefreshBook46(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:3316
Number of repeating InstrAttribType entries.
Definition: Messages.h:1477
bool mainFraction(UInt8 &value) const
Price Denominator of Main Fraction.
Definition: Messages.h:490
bool minPriceIncrementAmount(Decimal &value) const
Monetary value equivalent to the minimum price fluctuation.
Definition: Messages.h:602
IncrementalRefreshVolume37(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:4009
static StrRef fixType()
FIX message type.
Definition: Messages.h:1060
bool maxPriceVariation(Decimal &value) const
Differential static value for price banding.
Definition: Messages.h:3624
UInt8 underlyingProduct() const
Product complex.
Definition: Messages.h:1676
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:3899
static StrRef fixType()
FIX message type.
Definition: Messages.h:2117
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2192
bool originalContractSize(Int32 &value) const
Fixed contract value assigned to each product.
Definition: Messages.h:1979
AdminLogout409()
Initializes blank instance.
Definition: Messages.h:1253
bool lowLimitPrice(Decimal &value) const
Allowable low limit price for the trading day.
Definition: Messages.h:1929
UpdateAction::Enum updateAction() const
Order book update action to be applied to the order referenced by OrderID.
Definition: Messages.h:5722
LotTypeRules lotTypeRules() const
Returns instance of LotTypeRules repeating group.
Definition: Messages.h:2915
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:209
StrRef unitOfMeasure() const
Unit of measure for the products&#39; original contract size.
Definition: Messages.h:1856
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4806
Timestamp eventTime() const
Date and Time of instument Activation or Expiration event sent as number of nanoseconds since Unix ep...
Definition: Messages.h:1393
bool tradingReferenceDate(Timestamp &value) const
Indicates session date corresponding to the settlement price in tag 1150-TradingReferencePrice.
Definition: Messages.h:2046
FeedTypes feedTypes() const
Returns instance of FeedTypes repeating group.
Definition: Messages.h:2081
SecurityIDSource securityIdSource() const
Identifies class or source of the security ID (Tag 48) value.
Definition: Messages.h:2588
RelatedInstrumentsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4834
Int16 applId() const
Indicates the channel ID as defined in the XML configuration file.
Definition: Messages.h:925
bool securityAltIdSource(SecurityAltIDSource::Enum &value) const
Identifies class or source of the SecurityAltID (455) value.
Definition: Messages.h:764
static BlockLength blockLength(SchemaVersion version)
Size of message body in bytes.
Definition: Messages.h:2100
SettlPriceType settlPriceType() const
Bitmap field of eight Boolean type indicators representing settlement price type. ...
Definition: Messages.h:3468
MDIncrementalRefreshTradeSummary.
Definition: Messages.h:5397
bool maturityMonthYear(MaturityMonthYear &value) const
This field provides the actual calendar date for contract maturity.
Definition: Messages.h:2613
Char UserDefinedInstrument
UserDefinedInstrument type.
Definition: Fields.h:186
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4437
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:4043
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:1609
Int8 heartBtInt() const
Heartbeat interval (seconds).
Definition: Messages.h:1095
Int8 legRatioQty() const
Leg ratio of quantity for this individual leg relative to the entire multi-leg instrument.
Definition: Messages.h:2399
IncrementalRefreshTradeSummary48()
Initializes blank instance.
Definition: Messages.h:5574
SecurityIDSource underlyingSecurityIdSource() const
This value is always &#39;8&#39; for CME.
Definition: Messages.h:4789
BlockLength blockLength() const
Returns length of the block containing fixed-length fields of the given entry.
bool tradingReferencePrice(Decimal &value) const
Reference price - the most recently available Settlement whether it be Theoretical, Preliminary or a Final Settle of the session.
Definition: Messages.h:5231
InstAttribType instAttribType() const
Instrument Eligibility Attributes.
Definition: Messages.h:4667
InstAttribEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1487
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:3178
SecurityIDSource relatedSecurityIdSource() const
Related Security ID source.
Definition: Messages.h:4850
Timestamp lastUpdateTime() const
Timestamp of when the instrument was last added, modified or deleted.
Definition: Messages.h:1639
UInt32 totNumReports() const
Total number of instruments in the replayed loop.
Definition: Messages.h:5940
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:4904
bool openInterestQty(Int32 &value) const
The total open interest for the market at the close of the prior trading session. ...
Definition: Messages.h:1898
BinaryGroupEntry< GroupSize8Byte::BlockLength > Base
Aliases base class type.
Definition: Messages.h:5524
StrRef currency() const
Identifies currency used for price.
Definition: Messages.h:2623
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:5740
UInt32 rptSeq() const
Market Data entry sequence number per instrument update.
Definition: Messages.h:3964
static BlockLength blockLength(SchemaVersion version)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3207
static StrRef fixType()
FIX message type.
Definition: Messages.h:1010
CHAR matchAlgorithm() const
Matching algorithm.
Definition: Messages.h:1782
static StrRef fixType()
FIX message type.
Definition: Messages.h:1118
Encapsulates services for manipulating SBE-encoded messages.
StrRef cfiCode() const
ISO standard instrument categorization code.
Definition: Messages.h:2603
StrRef countryOfIssue() const
Country of Origin, ISO alpha-2 country code.
Definition: Messages.h:721
LotTypeRulesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2308
Decimal entryPx() const
Market Data entry price.
Definition: Messages.h:3776
bool tradingReferenceDate(Timestamp &value) const
Indicates trade session date corresponding to a statistic entry.
Definition: Messages.h:3449
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:4334
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2137
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:5894
static const Char * className()
Entity class name.
Definition: Messages.h:1466
BinaryGroup< FeedTypesEntry, GroupSize, MessageSize > FeedTypes
Repeating group containing FeedTypesEntry entries.
Definition: Messages.h:4645
IntegralConstant< Int8, 0 > UpdateActionNew
MDUpdateActionNew.
Definition: Fields.h:93
InstAttrib instAttrib() const
Returns instance of InstAttrib repeating group.
Definition: Messages.h:2909
UInt32 maxTradeVol() const
The maximum trading volume for a security.
Definition: Messages.h:462
static const Char * className()
Entity class name.
Definition: Messages.h:1410
bool highLimitPrice(Decimal &value) const
Allowable high limit price for the trading day.
Definition: Messages.h:571
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:5989
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:5503
bool lowLimitPrice(Decimal &value) const
Allowable low limit price for the trading day.
Definition: Messages.h:581
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1104
static const Char * className()
Returns class name.
Definition: Messages.h:1291
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:3703
Underlyings underlyings() const
Returns instance of Underlyings repeating group.
Definition: Messages.h:5354
SnapshotFullRefreshOrderBook53()
Initializes blank instance.
Definition: Messages.h:5911
Events events() const
Returns instance of Events repeating group.
Definition: Messages.h:2075
IncrementalRefreshVolume37()
Initializes blank instance.
Definition: Messages.h:4006
Events events() const
Returns instance of Events repeating group.
Definition: Messages.h:2897
StrRef toStrRef(const std::string &str)
Constructs StrRef instance over std::string content.
Definition: String.h:155
bool tradeDate(Timestamp &value) const
Trade session date sent as number of days since Unix epoch.
Definition: Messages.h:4276
bool highLimitPrice(Decimal &value) const
Allowable high limit price for the trading day.
Definition: Messages.h:1919
SecurityTradingEvent::Enum securityTradingEvent() const
Identifies an additional event or a rule related to the status.
Definition: Messages.h:3065
FeedTypesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4603
Int32 securityId() const
Security ID.
Definition: Messages.h:3143
#define ONIXS_CMEMDH_LTWT_EXPORTED
Definition: Bootstrap.h:47
static BlockLength blockLength(SchemaVersion version)
Size of message body in bytes.
Definition: Messages.h:2928
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1533
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:5594
StrRef securityGroup() const
Security Group Code.
Definition: Messages.h:4987
bool entrySize(Int32 &value) const
Market Data entry size.
Definition: Messages.h:3422
GroupSize::BlockLength BlockLength
Represents the length of binary block storing fixed-length fields of the group entry.
static const Char * className()
Entity class name.
Definition: Messages.h:1579
Encapsulates operations over SBE-encoded repeating group.
static const Char * className()
Returns class name.
Definition: Messages.h:1171
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:3712
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4705
Timestamp lastUpdateTime() const
UTC Date and time of last Security Definition add, update or delete on a given Market Data channel...
Definition: Messages.h:4268
Number of entries in Market Data message.
Definition: Messages.h:3758
static const Char * className()
Returns class name.
Definition: Messages.h:3562
void throwBadBinaryData(const Char *className)
Throws exception on bad repeating group entry.
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:5410
MDIncrementalRefreshVolume.
Definition: Messages.h:3920
InstAttrib instAttrib() const
Returns instance of InstAttrib repeating group.
Definition: Messages.h:2087
BinaryGroup< FeedTypesEntry, GroupSize, MessageSize > FeedTypes
Repeating group containing FeedTypesEntry entries.
Definition: Messages.h:1473
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:2467
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:4541
StrRef partyRoleClearingOrg() const
Clearing organization.
Definition: Messages.h:785
StrRef strikeCurrency() const
Currency in which the StrikePrice is denominated.
Definition: Messages.h:5085
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:989
bool entrySize(Int32 &value) const
Market Data entry size.
Definition: Messages.h:3133
Int8 heartBtInt() const
Heartbeat interval (seconds).
Definition: Messages.h:1214
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:904
Number of repeating FeedType repeating group entries.
Definition: Messages.h:97
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1284
StrRef priceQuoteMethod() const
Price quotation method.
Definition: Messages.h:775
EventType::Enum eventType() const
Code to represent the type of event.
Definition: Messages.h:60
static StrRef fixType()
FIX message type.
Definition: Messages.h:3377
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:3884
static const Char * className()
Entity class name.
Definition: Messages.h:5510
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:79
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4684
Number of repeating EventType entries.
Definition: Messages.h:1366
UInt16 UInt16
uInt16 optional.
Definition: Fields.h:189
RelatedSym relatedSym() const
Returns instance of RelatedSym repeating group.
Definition: Messages.h:4500
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5417
Number of entries in Market Data message.
Definition: Messages.h:4081
AdminLogout16()
Initializes blank instance.
Definition: Messages.h:1134
StrRef feedType() const
Describes a class of service for a given data feed.
Definition: Messages.h:1440
bool subFraction(UInt8 &value) const
Price Denominator of Sub Fraction.
Definition: Messages.h:2815
bool strikePrice(Decimal &value) const
Strike Price for an option instrument.
Definition: Messages.h:5075
InstrumentDefinitionSpread56()
Initializes blank instance.
Definition: Messages.h:2447
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:5754
SecurityIDSource legSecurityIdSource() const
Identifies source of tag 602-LegSecurityID value.
Definition: Messages.h:2384
UInt32 totNumReports() const
Total number of messages replayed in the loop.
Definition: Messages.h:4233
LotTypeRulesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4712
BinaryGroup< OrderIDEntry, GroupSize8Byte, MessageSize > OrderIDEntries
Repeating group containing OrderIDEntry entries.
Definition: Messages.h:5571
LotTypeRulesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:216
FeedTypesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1431
InstAttribEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:163
bool priceLevel(Int8 &value) const
Aggregate book position.
Definition: Messages.h:4129
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current market state of the instrument.
Definition: Messages.h:324
bool totNumReports(UInt32 &value) const
Total number of instruments in the Replay loop.
Definition: Messages.h:295
bool totNumReports(UInt32 &value) const
Total number of instruments in the Replay loop.
Definition: Messages.h:2476
EventsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2144
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:3531
bool mainFraction(UInt8 &value) const
Price Denominator of Main Fraction.
Definition: Messages.h:5177
InstAttrib instAttrib() const
Returns instance of InstAttrib repeating group.
Definition: Messages.h:847
bool lowLimitPrice(Decimal &value) const
Lower price threshold for the instrument.
Definition: Messages.h:3614
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:996
bool parValue(Decimal &value) const
Par value.
Definition: Messages.h:678
bool tradeableSize(Int32 &value) const
Tradeable qty.
Definition: Messages.h:3194
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:972
IncrementalRefreshBook46()
Initializes blank instance.
Definition: Messages.h:3313
UInt64 orderId() const
Unique Order ID.
Definition: Messages.h:5850
bool openInterestQty(Int32 &value) const
The total open interest for the market at the close of the prior trading session. ...
Definition: Messages.h:5262
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:5835
static const Char * className()
Entity class name.
Definition: Messages.h:4582
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3768
OrderUpdateAction::Enum orderUpdateAction() const
Order book update action to be applied to the order referenced by OrderID.
Definition: Messages.h:3286
static const Char * className()
Entity class name.
Definition: Messages.h:4444
Int32 numberOfOrders() const
The total number of real orders per instrument that participated in a match step within a match event...
Definition: Messages.h:5458
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3989
BinaryGroup< InstAttribEntry, GroupSize, MessageSize > InstAttrib
Repeating group containing InstAttribEntry entries.
Definition: Messages.h:4698
IncrementalRefreshLimitsBanding50()
Initializes blank instance.
Definition: Messages.h:3683
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:2227
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:3680
bool numberOfOrders(Int32 &value) const
Aggregate number of orders at the given price level.
Definition: Messages.h:4119
IncrementalRefreshDailyStatistics49(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:3514
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:2795
static StrRef fixType()
FIX message type.
Definition: Messages.h:877
IncrementalRefreshTradeSummary48(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:5577
EntryTypeLimits entryType() const
Market Data entry type.
Definition: Messages.h:3658
Int8 lotType() const
This tag is required to interpret the value in tag 1231-MinLotSize.
Definition: Messages.h:2317
EntryTypeVol entryType() const
Electronic Volume entry provides cumulative session trade volume updated with the event...
Definition: Messages.h:3981
bool lowLimitPrice(Decimal &value) const
Allowable low limit price for the trading day.
Definition: Messages.h:5272
MDInstrumentDefinitionFuture.
Definition: Messages.h:1356
static const Char * className()
Entity class name.
Definition: Messages.h:3501
static BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:3363
bool minCabPrice(Decimal &value) const
Defines cabinet price for outright options products.
Definition: Messages.h:5104
StrRef issuer() const
Name of security issuer or the Legal Entity Identifier (LEI - the International ISO standard 17442)...
Definition: Messages.h:732
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:4492
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:5908
bool unitOfMeasureQty(Decimal &value) const
This field contains the contract size for each instrument.
Definition: Messages.h:1866
bool maturityDate(Timestamp &value) const
Maturity Date.
Definition: Messages.h:648
EntryType::Enum entryType() const
Market Data entry type.
Definition: Messages.h:4177
IncrementalRefreshOrderBook47(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:5760
Int8 Int8
int8.
Definition: Fields.h:63
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:3508
StrRef couponDayCount() const
The day count convention used in interest calculations for a bond or an interest bearing security...
Definition: Messages.h:711
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3933
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:5982
StrRef symbol() const
Instrument Name or Symbol.
Definition: Messages.h:1711
bool tradingReferenceDate(Timestamp &value) const
Indicates session date corresponding to the settlement price in tag 1150-TradingReferencePrice.
Definition: Messages.h:5301
EntryTypeBook::Enum entryType() const
Market Data entry type.
Definition: Messages.h:5730
SecurityIDSource securityIdSource() const
Identifies class or source of tag 48-SecurityID value.
Definition: Messages.h:1728
static const Char * className()
Entity class name.
Definition: Messages.h:5747
UInt8 marketSegmentId() const
Identifies the market segment, populated for all CME Globex instruments.
Definition: Messages.h:1668
MDInstrumentDefinitionOption.
Definition: Messages.h:4528
static const Char * className()
Entity class name.
Definition: Messages.h:3303
InstrumentDefinitionOption55()
Initializes blank instance.
Definition: Messages.h:4884
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3596
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:4744
static StrRef fixType()
FIX message type.
Definition: Messages.h:5815
bool orderPriority(UInt64 &value) const
Order priority for execution on the order book.
Definition: Messages.h:5683
StrRef securityGroup() const
Security Group.
Definition: Messages.h:2989
bool entryPx(Decimal &value) const
Market Data entry price.
Definition: Messages.h:3123
SecurityUpdateAction::Enum securityUpdateAction() const
Last Security update action on Incremental feed, &#39;D&#39; or &#39;M&#39; is used when a mid-week deletion or modif...
Definition: Messages.h:2488
static const Char * className()
Entity class name.
Definition: Messages.h:2437
SchemaVersion version() const
Version of message being referenced.
UInt32 minTradeVol() const
The minimum trading volume for a security.
Definition: Messages.h:454
UnderlyingsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4772
StrRef cfiCode() const
ISO standard instrument categorization code.
Definition: Messages.h:1743
UInt32 maxTradeVol() const
The maximum trading volume for a security.
Definition: Messages.h:1798
UInt32 rptSeq() const
Sequence number of the last Market Data entry processed for the instrument.
Definition: Messages.h:4250
Number of repeating EventType entries.
Definition: Messages.h:2134
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:2981
static const Char * className()
Returns class name.
Definition: Messages.h:2938
Decimal displayFactor() const
Contains the multiplier to convert the CME Globex display price to the conventional price...
Definition: Messages.h:1816
bool instrumentGUId(UInt64 &value) const
External unique instrument ID.
Definition: Messages.h:825
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2301
static const Char * className()
Entity class name.
Definition: Messages.h:3217
bool tradingReferenceDate(Timestamp &value) const
Indicates session date corresponding to the reference price in tag 1150-TradingReferencePrice.
Definition: Messages.h:553
Timestamp eventTime() const
Date and Time of instrument Activation or Expiration event sent as number of nanoseconds since Unix e...
Definition: Messages.h:69
static StrRef fixType()
FIX message type.
Definition: Messages.h:3088
Int32 securityId() const
Security ID.
Definition: Messages.h:4399
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:2340
BinaryGroup< EventsEntry, GroupSize, MessageSize > Events
Repeating group containing EventsEntry entries.
Definition: Messages.h:2185
bool highLimitPrice(Decimal &value) const
Allowable high limit price for the trading day.
Definition: Messages.h:5282
EntryTypeTrade entryType() const
Market Data entry type.
Definition: Messages.h:5485
InstAttribValue instAttribValue() const
Bitmap field of 32 Boolean type Instrument eligibility flags.
Definition: Messages.h:2270
UInt32 maxTradeVol() const
The maximum trading volume for a security.
Definition: Messages.h:5130
SecurityUpdateAction::Enum securityUpdateAction() const
Last Security update action on Incremental feed, &#39;D&#39; or &#39;M&#39; is used when a mid-week deletion or modif...
Definition: Messages.h:307
StrRef unitOfMeasure() const
Unit of measure for the products&#39; original contract size.
Definition: Messages.h:2723
SettlPriceType settlPriceType() const
Bitmap field of eight Boolean type indicators representing settlement price type. ...
Definition: Messages.h:5242
StrRef riskSet() const
Risk Set identifies the list of instruments sharing credit limits set up.
Definition: Messages.h:2855
BinaryGroup< InstAttribEntry, GroupSize, MessageSize > InstAttrib
Repeating group containing InstAttribEntry entries.
Definition: Messages.h:202
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the trading status applicable to the instrument or Security Group.
Definition: Messages.h:3046
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current state of the instrument.
Definition: Messages.h:2506
Int32 lastQty() const
Quantity bought or sold on this last fill.
Definition: Messages.h:5547
static StrRef fixType()
FIX message type.
Definition: Messages.h:4355
IntegralConstant< Int8, 0 > UpdateTypeNew
MDUpdateTypeNew.
Definition: Fields.h:96
InstrumentDefinitionFuture54()
Initializes blank instance.
Definition: Messages.h:1589
UInt32 lastMsgSeqNumProcessed() const
Sequence number of the last Incremental feed packet processed.
Definition: Messages.h:4225
InstAttribEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4659
LegsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2368
bool highLimitPrice(Decimal &value) const
Upper price threshold for the instrument.
Definition: Messages.h:4304
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:5603
BinaryGroupEntry< GroupSize8Byte::BlockLength > Base
Aliases base class type.
Definition: Messages.h:3231
static const Char * className()
Entity class name.
Definition: Messages.h:5564
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:5477
OrderIDEntries orderIdEntries() const
Returns instance of OrderIDEntries repeating group.
Definition: Messages.h:5617
Int8 lotType() const
This tag is required to interpret the value in tag 1231-MinLotSize.
Definition: Messages.h:1549
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:188
StrRef financialInstrumentFullName() const
Long name of the instrument.
Definition: Messages.h:2887
UInt32 rptSeq() const
Market Data entry sequence number per instrument update.
Definition: Messages.h:3440
static const Char * className()
Returns class name.
Definition: Messages.h:870
Int32 entrySize() const
Cumulative traded volume.
Definition: Messages.h:3948
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:5777
static const Char * className()
Returns class name.
Definition: Messages.h:1230
Integral constant.
Definition: Integral.h:83
BinaryGroup< LotTypeRulesEntry, GroupSize, MessageSize > LotTypeRules
Repeating group containing LotTypeRulesEntry entries.
Definition: Messages.h:2354
Int32 securityId() const
Security ID.
Definition: Messages.h:5948
StrRef text() const
Free format text string.
Definition: Messages.h:1274
bool entryPx(Decimal &value) const
Market Data entry price.
Definition: Messages.h:3412
StrRef currency() const
Identifies the currency used for price.
Definition: Messages.h:427
MDInstrumentDefinitionFixedIncome.
Definition: Messages.h:32
StrRef securityType() const
Security Type.
Definition: Messages.h:409
EntryTypeDailyStatistics::Enum entryType() const
Market Data entry type.
Definition: Messages.h:3484
bool displayQty(Int32 &value) const
Visible order qty.
Definition: Messages.h:5703
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:3666
InstrumentDefinitionOption55(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:4887
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:3548
IncrementalRefreshDailyStatistics49()
Initializes blank instance.
Definition: Messages.h:3511
MDIncrementalRefreshLimitsBanding.
Definition: Messages.h:3576
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:1572
Decimal displayFactor() const
Contains the multiplier to convert the CME Globex display price to the conventional price...
Definition: Messages.h:2685
Number of entries in Market Data message.
Definition: Messages.h:5655
UInt32 currentChunk() const
Chunk sequence.
Definition: Messages.h:5965
bool unitOfMeasureQty(Decimal &value) const
This field contains the contract size for each instrument.
Definition: Messages.h:5219
static BlockLength blockLength(SchemaVersion)
Returns size of entry body in bytes for given version of message template.
Definition: Messages.h:1512
Timestamp transactTime() const
Start of event processing time in number of nanoseconds since Unix epoch.
Definition: Messages.h:4474
bool couponRate(Decimal &value) const
The rate of interest that, when multiplied by the principal, par value, or face value of a bond...
Definition: Messages.h:668
Int32 securityId() const
Security ID.
Definition: Messages.h:4241
#define ONIXS_CMEMDH_NAMESPACE_END
Definition: Bootstrap.h:68
MatchEventIndicator matchEventIndicator() const
Bitmap field of eight Boolean type indicators reflecting the end of updates for a given Globex event...
Definition: Messages.h:981