OnixS C++ CME MDP Premium Market Data Handler  5.8.7
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.