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