OnixS C++ CME Streamlined Market Data Handler  1.0.0.4
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 /// AdminHeartbeat.
35 {
36  /// Message template ID from SBE schema.
37  enum { TemplateId = 312 };
38 
39  /// Initializes blank instance.
41  {
42  }
43 
44  /// Initializes instance over given memory block.
46  const void* data,
47  MessageSize size)
48  : BinaryMessage(data, size)
49  {
50  assert(TemplateId == templateId());
51 
52  if (size < bodySize(version()))
53  throwBadBinaryData(className());
54  }
55 
56  /// Size of message body in bytes.
59  {
60  return 0;
61  }
62 
63  /// Returns class name.
65  static const Char* className()
66  {
67  return "AdminHeartbeat312";
68  }
69 
70  /// FIX message type.
72  static StrRef fixType()
73  {
74  return toStrRef("0");
75  }
76 };
77 
78 /// AdminLogin.
82 {
83  /// Message template ID from SBE schema.
84  enum { TemplateId = 315 };
85 
86  /// Initializes blank instance.
88  {
89  }
90 
91  /// Initializes instance over given memory block.
93  const void* data,
94  MessageSize size)
95  : BinaryMessage(data, size)
96  {
97  assert(TemplateId == templateId());
98 
99  if (size < bodySize(version()))
100  throwBadBinaryData(className());
101  }
102 
103  /// Heartbeat interval (seconds).
104  Int8 heartBtInt() const
105  {
106  const BodySize offset = 0;
107 
108  return ordinary<Int8>(offset);
109  }
110 
111  /// Size of message body in bytes.
114  {
115  return 1;
116  }
117 
118  /// Returns class name.
120  static const Char* className()
121  {
122  return "AdminLogin315";
123  }
124 
125  /// FIX message type.
127  static StrRef fixType()
128  {
129  return toStrRef("A");
130  }
131 };
132 
133 /// AdminLogout.
137 {
138  /// Message template ID from SBE schema.
139  enum { TemplateId = 316 };
140 
141  /// Initializes blank instance.
143  {
144  }
145 
146  /// Initializes instance over given memory block.
148  const void* data,
149  MessageSize size)
150  : BinaryMessage(data, size)
151  {
152  assert(TemplateId == templateId());
153 
154  if (size < bodySize(version()))
155  throwBadBinaryData(className());
156  }
157 
158  /// Free format text string. May include logout confirmation
159  /// or reason for logout.
160  StrRef text() const
161  {
162  const BodySize offset = 0;
163  const BodySize length = 180;
164 
165  return fixedStr<length>(offset);
166  }
167 
168  /// Size of message body in bytes.
171  {
172  return 180;
173  }
174 
175  /// Returns class name.
177  static const Char* className()
178  {
179  return "AdminLogout316";
180  }
181 
182  /// FIX message type.
184  static StrRef fixType()
185  {
186  return toStrRef("5");
187  }
188 };
189 
190 /// MDIncrementalRefreshErisReferenceDataAndDailyStatistics.
194 {
195  /// Message template ID from SBE schema.
196  enum { TemplateId = 333 };
197 
198  /// Number of entries in Market Data message..
199  /// Entry of Entry repeating group.
202  <
204  >
205  {
206  /// Aliases base class type.
207  typedef
209  <
211  >
213 
214  /// Initializes blank instance.
216  {
217  }
218 
219  /// Initializes instance of given
220  /// version over given memory block.
222  const void* data,
223  BodySize size,
224  SchemaVersion version)
225  : Base(data, size, version)
226  {
227  if (size < bodySize(version))
228  throwBadBinaryData(className());
229  }
230 
231  /// Number of entries in AltID group..
232  /// Entry of SecurityAltIDEntry repeating group.
235  <
237  >
238  {
239  /// Aliases base class type.
240  typedef
242  <
244  >
246 
247  /// Initializes blank instance.
249  {
250  }
251 
252  /// Initializes instance of given
253  /// version over given memory block.
255  const void* data,
256  BodySize size,
257  SchemaVersion version)
258  : Base(data, size, version)
259  {
260  if (size < bodySize(version))
261  throwBadBinaryData(className());
262  }
263 
264  /// Expanded instrument description.
265  bool securityAltId(StrRef& value) const
266  {
267  const BodySize offset = 0;
268  const BodySize length = 26;
269 
270  return fixedStr<length>(value, offset);
271  }
272 
273  /// Identifies class or source of the SecurityAltID (455)
274  /// value.
275  bool securityAltIdSource(CharNULL& value) const
276  {
277  typedef NullCharNULL Null;
278 
279  const BodySize offset = 26;
280 
281  return ordinary(value, offset, Null());
282  }
283 
284  /// Returns size of entry body in bytes
285  /// for given version of message template.
288  {
289  return 27;
290  }
291 
292  /// Entity class name.
294  static const Char* className()
295  {
296  return "Entries.SecurityAltIDEntry";
297  }
298  };
299 
300  /// Repeating group containing SecurityAltIDEntry entries.
301  typedef
304 
305  /// Number of related instruments group.
306  /// Entry of RelatedInstrumentsEntry repeating group.
309  <
311  >
312  {
313  /// Aliases base class type.
314  typedef
316  <
318  >
320 
321  /// Initializes blank instance.
323  {
324  }
325 
326  /// Initializes instance of given
327  /// version over given memory block.
329  const void* data,
330  BodySize size,
331  SchemaVersion version)
332  : Base(data, size, version)
333  {
334  if (size < bodySize(version))
335  throwBadBinaryData(className());
336  }
337 
338  /// The type of instrument relationship.
339  bool relatedInstrumentType(UInt8& value) const
340  {
341  typedef NullUInt8 Null;
342 
343  const BodySize offset = 0;
344 
345  return ordinary(value, offset, Null());
346  }
347 
348  /// Related instrument Symbol.
349  bool relatedSymbol(StrRef& value) const
350  {
351  const BodySize offset = 1;
352  const BodySize length = 50;
353 
354  return fixedStr<length>(value, offset);
355  }
356 
357  /// Instrument Symbol Suffix for T+1 (Next Trading day).
358  bool relatedSecurityGroup(StrRef& value) const
359  {
360  const BodySize offset = 51;
361  const BodySize length = 26;
362 
363  return fixedStr<length>(value, offset);
364  }
365 
366  /// Returns size of entry body in bytes
367  /// for given version of message template.
370  {
371  return 77;
372  }
373 
374  /// Entity class name.
376  static const Char* className()
377  {
378  return "Entries.RelatedInstrumentsEntry";
379  }
380  };
381 
382  /// Repeating group containing RelatedInstrumentsEntry entries.
383  typedef
386 
387  /// Number of repeating EventType entries..
388  /// Entry of EventsEntry repeating group.
391  <
393  >
394  {
395  /// Aliases base class type.
396  typedef
398  <
400  >
402 
403  /// Initializes blank instance.
405  {
406  }
407 
408  /// Initializes instance of given
409  /// version over given memory block.
411  const void* data,
412  BodySize size,
413  SchemaVersion version)
414  : Base(data, size, version)
415  {
416  if (size < bodySize(version))
417  throwBadBinaryData(className());
418  }
419 
420  /// Code to represent the type of event.
421  bool eventType(UInt8& value) const
422  {
423  typedef NullUInt8 Null;
424 
425  const BodySize offset = 0;
426 
427  return ordinary(value, offset, Null());
428  }
429 
430  /// Time of event. This is number of days since unix epoch.
431  bool eventTime(UInt64& value) const
432  {
433  typedef NullUInt64 Null;
434 
435  const BodySize offset = 1;
436 
437  return ordinary(value, offset, Null());
438  }
439 
440  /// Returns size of entry body in bytes
441  /// for given version of message template.
444  {
445  return 9;
446  }
447 
448  /// Entity class name.
450  static const Char* className()
451  {
452  return "Entries.EventsEntry";
453  }
454  };
455 
456  /// Repeating group containing EventsEntry entries.
457  typedef
460 
461  /// Indicates the type of Market Data update action.
463  {
464  const BodySize offset = 0;
465 
466  return ordinary<CHAR>(offset);
467  }
468 
469  /// Indicates the type of Market Data entry.
470  CHAR entryType() const
471  {
472  const BodySize offset = 1;
473 
474  return ordinary<CHAR>(offset);
475  }
476 
477  /// Sequence number per Index update.
478  UInt32 rptSeq() const
479  {
480  const BodySize offset = 2;
481 
482  return ordinary<UInt32>(offset);
483  }
484 
485  /// Price of the Market Data Entry.
486  bool entryPx(Decimal64& value) const
487  {
488  typedef NullDecimal64 Null;
489 
490  const BodySize offset = 6;
491 
492  return ordinary(value, offset, Null());
493  }
494 
495  /// Flag that identifies a market data entry.
496  bool openCloseSettlFlag(UInt8& value) const
497  {
498  typedef NullUInt8 Null;
499 
500  const BodySize offset = 15;
501 
502  return ordinary(value, offset, Null());
503  }
504 
505  /// Indicates reference price as calculated, final or
506  /// preliminary settle.
508  {
509  const BodySize offset = 16;
510 
511  return ordinary<SettlPriceType>(offset);
512  }
513 
514  /// Calculated Futures Price using Swap NPV, Historical fixed
515  /// and floating amounts and synthetic interest on variation
516  /// margin.
517  bool calFutPx(Decimal64& value) const
518  {
519  typedef NullDecimal64 Null;
520 
521  const BodySize offset = 17;
522 
523  return ordinary(value, offset, Null());
524  }
525 
526  /// For future use.
527  bool referenceId(StrRef& value) const
528  {
529  const BodySize offset = 26;
530  const BodySize length = 50;
531 
532  return fixedStr<length>(value, offset);
533  }
534 
535  /// Quantity or volume represented by the Market Data Entry.
536  bool entrySize(UInt64& value) const
537  {
538  typedef NullUInt64 Null;
539 
540  const BodySize offset = 76;
541 
542  return ordinary(value, offset, Null());
543  }
544 
545  /// Instrument, Index, Swap Name.
546  bool symbol(StrRef& value) const
547  {
548  const BodySize offset = 84;
549  const BodySize length = 50;
550 
551  return fixedStr<length>(value, offset);
552  }
553 
554  /// Indicates the product code for the instrument.
555  bool securityGroup(StrRef& value) const
556  {
557  const BodySize offset = 134;
558  const BodySize length = 26;
559 
560  return fixedStr<length>(value, offset);
561  }
562 
563  /// Indicates the type of product the instrument is associated
564  /// with in the message.
565  bool product(UInt8& value) const
566  {
567  typedef NullUInt8 Null;
568 
569  const BodySize offset = 160;
570 
571  return ordinary(value, offset, Null());
572  }
573 
574  /// Indicates type of security.
575  bool securityType(StrRef& value) const
576  {
577  const BodySize offset = 161;
578  const BodySize length = 9;
579 
580  return fixedStr<length>(value, offset);
581  }
582 
583  /// Market used to help identify an instrument.
585  {
586  const BodySize offset = 170;
587  const BodySize length = 4;
588 
589  return fixedStr<length>(offset);
590  }
591 
592  /// Maturity date of instrument.
593  bool maturityDate(Timestamp& value) const
594  {
595  typedef NullLocalMktDate Null;
596  typedef LocalMktDate FieldValue;
597 
598  const BodySize offset = 174;
599 
600  FieldValue fieldValue;
601 
602  if (ordinary(fieldValue, offset, Null()))
603  {
604  value = localMktDateToTimestamp(fieldValue);
605  return true;
606  }
607  return false;
608  }
609 
610  /// The rate of the fixed leg.
611  bool couponRate(Decimal32& value) const
612  {
613  typedef NullDecimal32 Null;
614 
615  const BodySize offset = 176;
616 
617  return ordinary(value, offset, Null());
618  }
619 
620  /// Pricing date.
621  bool tradeDate(Timestamp& value) const
622  {
623  typedef NullLocalMktDate Null;
624  typedef LocalMktDate FieldValue;
625 
626  const BodySize offset = 181;
627 
628  FieldValue fieldValue;
629 
630  if (ordinary(fieldValue, offset, Null()))
631  {
632  value = localMktDateToTimestamp(fieldValue);
633  return true;
634  }
635  return false;
636  }
637 
638  /// Shows the coupon rate that would result in a zero-NPV swap.
639  bool fairCouponPct(Decimal64& value) const
640  {
641  typedef NullDecimal64 Null;
642 
643  const BodySize offset = 183;
644 
645  return ordinary(value, offset, Null());
646  }
647 
648  /// The date the floating rate was set for the next floating
649  /// payment.
650  bool legPurchaseRate(Decimal64& value) const
651  {
652  typedef NullDecimal64 Null;
653 
654  const BodySize offset = 192;
655 
656  return ordinary(value, offset, Null());
657  }
658 
659  /// The NPV (Net Present Value) for the fixed leg of the
660  /// trade, calculated that day. NPV is per 100 notional.
661  bool fixedNPV(Decimal64& value) const
662  {
663  typedef NullDecimal64 Null;
664 
665  const BodySize offset = 201;
666 
667  return ordinary(value, offset, Null());
668  }
669 
670  /// The NPV (Net Present Value) for the floating leg of the
671  /// trade, calculated that day. NPV is per 100 notional.
672  bool floatNPV(Decimal64& value) const
673  {
674  typedef NullDecimal64 Null;
675 
676  const BodySize offset = 210;
677 
678  return ordinary(value, offset, Null());
679  }
680 
681  /// The NPV represents net present value of the future cash
682  /// flows at time t.
683  bool npv(Decimal64& value) const
684  {
685  typedef NullDecimal64 Null;
686 
687  const BodySize offset = 219;
688 
689  return ordinary(value, offset, Null());
690  }
691 
692  /// This value represents accumulated fixed and floating
693  /// amounts.
694  bool accruedCoupons(Decimal64& value) const
695  {
696  typedef NullDecimal64 Null;
697 
698  const BodySize offset = 228;
699 
700  return ordinary(value, offset, Null());
701  }
702 
703  /// This number represents the day over day variation margin
704  /// for 1 contract for this instrument ID or Eris PAI.
706  {
707  typedef NullDecimal64 Null;
708 
709  const BodySize offset = 237;
710 
711  return ordinary(value, offset, Null());
712  }
713 
714  /// This is the cumulative daily interest adjustment.
715  bool erisPAI(Decimal64& value) const
716  {
717  typedef NullDecimal64 Null;
718 
719  const BodySize offset = 246;
720 
721  return ordinary(value, offset, Null());
722  }
723 
724  /// The Fed Funds Rate published for the Fed Funds Date by the
725  /// New York Federal Reserve.
726  bool fedFundsRate(Decimal64& value) const
727  {
728  typedef NullDecimal64 Null;
729 
730  const BodySize offset = 255;
731 
732  return ordinary(value, offset, Null());
733  }
734 
735  /// Minimum tick for a product (only sent if not eligible for
736  /// VTT).
737  bool minPriceIncrement(Decimal64& value) const
738  {
739  typedef NullDecimal64 Null;
740 
741  const BodySize offset = 264;
742 
743  return ordinary(value, offset, Null());
744  }
745 
746  /// Fixed payment that occurs on the Evaluation Date.
747  bool fixedPayment(Decimal64& value) const
748  {
749  typedef NullDecimal64 Null;
750 
751  const BodySize offset = 273;
752 
753  return ordinary(value, offset, Null());
754  }
755 
756  /// Floating Payment that occurs on the Evaulation Date.
757  bool floatingPayment(Decimal64& value) const
758  {
759  typedef NullDecimal64 Null;
760 
761  const BodySize offset = 282;
762 
763  return ordinary(value, offset, Null());
764  }
765 
766  /// The date the next fixed payment will be made.
767  bool nextFixedPaymentDate(Timestamp& value) const
768  {
769  typedef NullLocalMktDate Null;
770  typedef LocalMktDate FieldValue;
771 
772  const BodySize offset = 291;
773 
774  FieldValue fieldValue;
775 
776  if (ordinary(fieldValue, offset, Null()))
777  {
778  value = localMktDateToTimestamp(fieldValue);
779  return true;
780  }
781  return false;
782  }
783 
784  /// The next fixed payment amount.
786  {
787  typedef NullDecimal64 Null;
788 
789  const BodySize offset = 293;
790 
791  return ordinary(value, offset, Null());
792  }
793 
794  /// The next floating payment amount.
796  {
797  typedef NullDecimal64 Null;
798 
799  const BodySize offset = 302;
800 
801  return ordinary(value, offset, Null());
802  }
803 
804  /// Indicates the business date for previous settlement price.
805  bool tradingReferenceDate(Timestamp& value) const
806  {
807  typedef NullLocalMktDate Null;
808  typedef LocalMktDate FieldValue;
809 
810  const BodySize offset = 311;
811 
812  FieldValue fieldValue;
813 
814  if (ordinary(fieldValue, offset, Null()))
815  {
816  value = localMktDateToTimestamp(fieldValue);
817  return true;
818  }
819  return false;
820  }
821 
822  /// The Eris PAI on the Previous Settlement Date.
823  bool previousErisPAI(Decimal64& value) const
824  {
825  typedef NullDecimal64 Null;
826 
827  const BodySize offset = 313;
828 
829  return ordinary(value, offset, Null());
830  }
831 
832  /// The date that the for which the fed funds date was
833  /// published.
834  bool fedFundsDate(Timestamp& value) const
835  {
836  typedef NullLocalMktDate Null;
837  typedef LocalMktDate FieldValue;
838 
839  const BodySize offset = 322;
840 
841  FieldValue fieldValue;
842 
843  if (ordinary(fieldValue, offset, Null()))
844  {
845  value = localMktDateToTimestamp(fieldValue);
846  return true;
847  }
848  return false;
849  }
850 
851  /// How many days have passed since settlement price was last
852  /// calculated.
853  bool accrualDays(UInt32& value) const
854  {
855  typedef NullUInt32 Null;
856 
857  const BodySize offset = 324;
858 
859  return ordinary(value, offset, Null());
860  }
861 
862  /// This is the notional value used to calculate NPV and Fixed
863  /// and Floating Payment amounts.
864  bool minal(UInt64& value) const
865  {
866  typedef NullUInt64 Null;
867 
868  const BodySize offset = 328;
869 
870  return ordinary(value, offset, Null());
871  }
872 
873  /// Description of Float Rate.
874  bool legCreditRating(StrRef& value) const
875  {
876  const BodySize offset = 336;
877  const BodySize length = 6;
878 
879  return fixedStr<length>(value, offset);
880  }
881 
882  /// Multiplier that when applied on longer rate results in
883  /// PreviousFixingRate.
884  bool legContractMultiplier(Decimal64& value) const
885  {
886  typedef NullDecimal64 Null;
887 
888  const BodySize offset = 342;
889 
890  return ordinary(value, offset, Null());
891  }
892 
893  /// The date the next floating payment will be made.
895  {
896  typedef NullLocalMktDate Null;
897  typedef LocalMktDate FieldValue;
898 
899  const BodySize offset = 351;
900 
901  FieldValue fieldValue;
902 
903  if (ordinary(fieldValue, offset, Null()))
904  {
905  value = localMktDateToTimestamp(fieldValue);
906  return true;
907  }
908  return false;
909  }
910 
911  /// The present value of a 1bp change in the fixed rate.
912  bool pV01(Decimal64& value) const
913  {
914  typedef NullDecimal64 Null;
915 
916  const BodySize offset = 353;
917 
918  return ordinary(value, offset, Null());
919  }
920 
921  /// Present value of on basis points change in value if yield
922  /// curve shifts 1bp.
923  bool dV01(Decimal64& value) const
924  {
925  typedef NullDecimal64 Null;
926 
927  const BodySize offset = 362;
928 
929  return ordinary(value, offset, Null());
930  }
931 
932  /// Final Settlement Price in NPV terms.
933  bool settlementNPV(Decimal64& value) const
934  {
935  typedef NullDecimal64 Null;
936 
937  const BodySize offset = 371;
938 
939  return ordinary(value, offset, Null());
940  }
941 
942  /// Final Settlement Futures Prices.
944  {
945  typedef NullDecimal64 Null;
946 
947  const BodySize offset = 380;
948 
949  return ordinary(value, offset, Null());
950  }
951 
952  /// Ticker symbol. Common, &amp;quot;human
953  /// understood&amp;quot; representation of the security.
954  bool securityDescription(StrRef& value) const
955  {
956  const BodySize offset = 389;
957  const BodySize length = 30;
958 
959  return fixedStr<length>(value, offset);
960  }
961 
962  /// Returns instance of SecurityAltID repeating group.
964  {
965  return
966  groups().
967  head<SecurityAltID>();
968  }
969 
970  /// Returns instance of RelatedInstruments repeating group.
972  {
973  return
974  groups().
975  tail<SecurityAltID>().
976  head<RelatedInstruments>();
977  }
978 
979  /// Returns instance of Events repeating group.
980  Events events() const
981  {
982  return
983  groups().
984  tail<SecurityAltID>().
985  tail<RelatedInstruments>().
986  head<Events>();
987  }
988 
989  /// Returns size of entry body in bytes
990  /// for given version of message template.
993  {
994  return 419;
995  }
996 
997  /// Returns reference to the next item.
999  {
1000  const void* body = events().end().get().body();
1001  return Entry(
1002  body,
1003  bodySize(version()),
1004  version());
1005  }
1006 
1007  /// Entity class name.
1009  static const Char* className()
1010  {
1011  return "IncrementalRefreshErisReferenceDataAndDailyStatistics333.Entry";
1012  }
1013  };
1014 
1015  /// Repeating group containing Entry entries.
1016  typedef
1019 
1020  /// Initializes blank instance.
1022  {
1023  }
1024 
1025  /// Initializes instance over given memory block.
1027  const void* data,
1028  MessageSize size)
1029  : BinaryMessage(data, size)
1030  {
1031  assert(TemplateId == templateId());
1032 
1033  if (size < bodySize(version()))
1034  throwBadBinaryData(className());
1035  }
1036 
1037  /// Start of event processing time in number of nanoseconds
1038  /// since Unix epoch.
1040  {
1041  const BodySize offset = 0;
1042 
1043  return ordinary<Timestamp>(offset);
1044  }
1045 
1046  /// Bitmap field of eight Boolean type indicators reflecting
1047  /// the end of updates for a given event.
1048  const MatchEventIndicator&
1050  {
1051  const BodySize offset = 8;
1052 
1053  return ordinary<MatchEventIndicator>(offset);
1054  }
1055 
1056  /// Total number of messages contained within batch which is
1057  /// defined by match event indicator (5799).
1058  bool batchTotalMessages(UInt16& value) const
1059  {
1060  typedef NullUInt16 Null;
1061 
1062  const BodySize offset = 9;
1063 
1064  return ordinary(value, offset, Null());
1065  }
1066 
1067  /// Returns instance of Entries repeating group.
1069  {
1070  return
1071  groups().
1072  head<Entries>();
1073  }
1074 
1075  /// Size of message body in bytes.
1078  {
1079  return 11;
1080  }
1081 
1082  /// Returns class name.
1084  static const Char* className()
1085  {
1086  return "IncrementalRefreshErisReferenceDataAndDailyStatistics333";
1087  }
1088 
1089  /// FIX message type.
1091  static StrRef fixType()
1092  {
1093  return toStrRef("X");
1094  }
1095 };
1096 
1097 /// MDNewsIndices.
1100 : BinaryMessage
1101 {
1102  /// Message template ID from SBE schema.
1103  enum { TemplateId = 339 };
1104 
1105  /// Specifies the number of repeating symbols specified..
1106  /// Entry of RelatedSymEntry repeating group.
1109  <
1111  >
1112  {
1113  /// Aliases base class type.
1114  typedef
1116  <
1118  >
1120 
1121  /// Initializes blank instance.
1123  {
1124  }
1125 
1126  /// Initializes instance of given
1127  /// version over given memory block.
1129  const void* data,
1130  BodySize size,
1131  SchemaVersion version)
1132  : Base(data, size, version)
1133  {
1134  if (size < bodySize(version))
1135  throwBadBinaryData(className());
1136  }
1137 
1138  /// A specific moniter assigned to a group of related
1139  /// securities which may be concurrently affected by market
1140  /// events and actions. Falcon ignores the incoming value
1141  /// except when null and returns back the correct one in the
1142  /// outgoing execution report.
1143  bool symbol(StrRef& value) const
1144  {
1145  const BodySize offset = 0;
1146  const BodySize length = 50;
1147 
1148  return fixedStr<length>(value, offset);
1149  }
1150 
1151  /// Returns size of entry body in bytes
1152  /// for given version of message template.
1155  {
1156  return 50;
1157  }
1158 
1159  /// Entity class name.
1161  static const Char* className()
1162  {
1163  return "NewsIndices339.RelatedSymEntry";
1164  }
1165  };
1166 
1167  /// Repeating group containing RelatedSymEntry entries.
1168  typedef
1171 
1172  /// Identifies number of lines of text body..
1173  /// Entry of LinesOfTextEntry repeating group.
1176  <
1178  >
1179  {
1180  /// Aliases base class type.
1181  typedef
1183  <
1185  >
1187 
1188  /// Initializes blank instance.
1190  {
1191  }
1192 
1193  /// Initializes instance of given
1194  /// version over given memory block.
1196  const void* data,
1197  BodySize size,
1198  SchemaVersion version)
1199  : Base(data, size, version)
1200  {
1201  if (size < bodySize(version))
1202  throwBadBinaryData(className());
1203  }
1204 
1205  /// This general purpose text field could contain any post-
1206  /// trade instructions used by customers based on mutual
1207  /// understanding with their clearing firm. If incoming value
1208  /// is greater than max length then take the right most fifty
1209  /// bytes. No validation is done for valid values and this is
1210  /// a pass through to clearing. After any right justification
1211  /// if applicable the incoming value is flipped back in the
1212  /// execution report and also becomes an attribute of the
1213  /// order.
1214  StrRef text() const
1215  {
1216  const BodySize offset = 0;
1217  const BodySize length = 500;
1218 
1219  return fixedStr<length>(offset);
1220  }
1221 
1222  /// Returns size of entry body in bytes
1223  /// for given version of message template.
1226  {
1227  return 500;
1228  }
1229 
1230  /// Entity class name.
1232  static const Char* className()
1233  {
1234  return "NewsIndices339.LinesOfTextEntry";
1235  }
1236  };
1237 
1238  /// Repeating group containing LinesOfTextEntry entries.
1239  typedef
1242 
1243  /// Initializes blank instance.
1245  {
1246  }
1247 
1248  /// Initializes instance over given memory block.
1250  const void* data,
1251  MessageSize size)
1252  : BinaryMessage(data, size)
1253  {
1254  assert(TemplateId == templateId());
1255 
1256  if (size < bodySize(version()))
1257  throwBadBinaryData(className());
1258  }
1259 
1260  /// The headline of a News message.
1261  bool headline(StrRef& value) const
1262  {
1263  const BodySize offset = 0;
1264  const BodySize length = 50;
1265 
1266  return fixedStr<length>(value, offset);
1267  }
1268 
1269  /// Time of message origination expressed as number of
1270  /// nanoseconds since unix epoch.
1271  bool origTime(Timestamp& value) const
1272  {
1273  typedef NullUInt64 Null;
1274 
1275  const BodySize offset = 50;
1276 
1277  return ordinary(value, offset, Null());
1278  }
1279 
1280  /// Describes a class of service for a given data feed.
1281  bool feedType(StrRef& value) const
1282  {
1283  const BodySize offset = 58;
1284  const BodySize length = 2;
1285 
1286  return fixedStr<length>(value, offset);
1287  }
1288 
1289  /// Returns instance of RelatedSym repeating group.
1291  {
1292  return
1293  groups().
1294  head<RelatedSym>();
1295  }
1296 
1297  /// Returns instance of LinesOfText repeating group.
1299  {
1300  return
1301  groups().
1302  tail<RelatedSym>().
1303  head<LinesOfText>();
1304  }
1305 
1306  /// Size of message body in bytes.
1309  {
1310  return 60;
1311  }
1312 
1313  /// Returns class name.
1315  static const Char* className()
1316  {
1317  return "NewsIndices339";
1318  }
1319 
1320  /// FIX message type.
1322  static StrRef fixType()
1323  {
1324  return toStrRef("B");
1325  }
1326 };
1327 
1328 /// MDIncrementalRefreshTradeBlocks.
1331 : BinaryMessage
1332 {
1333  /// Message template ID from SBE schema.
1334  enum { TemplateId = 340 };
1335 
1336  /// Number of entries in Market Data message..
1337  /// Entry of Entry repeating group.
1340  <
1342  >
1343  {
1344  /// Aliases base class type.
1345  typedef
1347  <
1349  >
1351 
1352  /// Initializes blank instance.
1354  {
1355  }
1356 
1357  /// Initializes instance of given
1358  /// version over given memory block.
1360  const void* data,
1361  BodySize size,
1362  SchemaVersion version)
1363  : Base(data, size, version)
1364  {
1365  if (size < bodySize(version))
1366  throwBadBinaryData(className());
1367  }
1368 
1369  /// Number of underlying legs that make up the security.
1370  /// Entry of UnderlyingsEntry repeating group.
1373  <
1375  >
1376  {
1377  /// Aliases base class type.
1378  typedef
1380  <
1382  >
1384 
1385  /// Initializes blank instance.
1387  {
1388  }
1389 
1390  /// Initializes instance of given
1391  /// version over given memory block.
1393  const void* data,
1394  BodySize size,
1395  SchemaVersion version)
1396  : Base(data, size, version)
1397  {
1398  if (size < bodySize(version))
1399  throwBadBinaryData(className());
1400  }
1401 
1402  /// Underlying Security's symbol.
1403  bool underlyingSymbol(StrRef& value) const
1404  {
1405  const BodySize offset = 0;
1406  const BodySize length = 50;
1407 
1408  return fixedStr<length>(value, offset);
1409  }
1410 
1411  /// Underlying Security's MaturityMonthYear.
1413  {
1414  typedef NullMaturityMonthYear Null;
1415 
1416  const BodySize offset = 50;
1417 
1418  return ordinary(value, offset, Null());
1419  }
1420 
1421  /// Underlying Security's SecurityType.
1422  bool underlyingSecurityType(StrRef& value) const
1423  {
1424  const BodySize offset = 55;
1425  const BodySize length = 9;
1426 
1427  return fixedStr<length>(value, offset);
1428  }
1429 
1430  /// Underlying Security's SecurityExchange.
1432  {
1433  const BodySize offset = 64;
1434  const BodySize length = 4;
1435 
1436  return fixedStr<length>(value, offset);
1437  }
1438 
1439  /// Returns size of entry body in bytes
1440  /// for given version of message template.
1443  {
1444  return 68;
1445  }
1446 
1447  /// Entity class name.
1449  static const Char* className()
1450  {
1451  return "Entries.UnderlyingsEntry";
1452  }
1453  };
1454 
1455  /// Repeating group containing UnderlyingsEntry entries.
1456  typedef
1459 
1460  /// Number of party roles.
1461  /// Entry of PartyIDsEntry repeating group.
1464  <
1466  >
1467  {
1468  /// Aliases base class type.
1469  typedef
1471  <
1473  >
1475 
1476  /// Initializes blank instance.
1478  {
1479  }
1480 
1481  /// Initializes instance of given
1482  /// version over given memory block.
1484  const void* data,
1485  BodySize size,
1486  SchemaVersion version)
1487  : Base(data, size, version)
1488  {
1489  if (size < bodySize(version))
1490  throwBadBinaryData(className());
1491  }
1492 
1493  /// Party identifier/code.
1494  bool partyId(StrRef& value) const
1495  {
1496  const BodySize offset = 0;
1497  const BodySize length = 50;
1498 
1499  return fixedStr<length>(value, offset);
1500  }
1501 
1502  /// Identifies the type or role of the PartyID specified.
1503  bool partyRole(StrRef& value) const
1504  {
1505  const BodySize offset = 50;
1506  const BodySize length = 2;
1507 
1508  return fixedStr<length>(value, offset);
1509  }
1510 
1511  /// Returns size of entry body in bytes
1512  /// for given version of message template.
1515  {
1516  return 52;
1517  }
1518 
1519  /// Entity class name.
1521  static const Char* className()
1522  {
1523  return "Entries.PartyIDsEntry";
1524  }
1525  };
1526 
1527  /// Repeating group containing PartyIDsEntry entries.
1528  typedef
1531 
1532  /// Number of legs (repeating groups).
1533  /// Entry of LegsEntry repeating group.
1536  <
1538  >
1539  {
1540  /// Aliases base class type.
1541  typedef
1543  <
1545  >
1547 
1548  /// Initializes blank instance.
1550  {
1551  }
1552 
1553  /// Initializes instance of given
1554  /// version over given memory block.
1556  const void* data,
1557  BodySize size,
1558  SchemaVersion version)
1559  : Base(data, size, version)
1560  {
1561  if (size < bodySize(version))
1562  throwBadBinaryData(className());
1563  }
1564 
1565  /// This tag contains the instrument group of the requested
1566  /// security definition. Must be present when tag 555-NoLegs
1567  /// is present. Also must be first tag in repeating group.
1568  /// Multileg instrument's individual security's Symbol.
1569  bool legSymbol(StrRef& value) const
1570  {
1571  const BodySize offset = 0;
1572  const BodySize length = 50;
1573 
1574  return fixedStr<length>(value, offset);
1575  }
1576 
1577  /// Multileg instrument's individual security's SecurityID.
1578  bool legSecurityId(UInt64& value) const
1579  {
1580  typedef NullUInt64 Null;
1581 
1582  const BodySize offset = 50;
1583 
1584  return ordinary(value, offset, Null());
1585  }
1586 
1587  /// Identifies source of tag 602-LegSecurityID value. This
1588  /// value is always 'H' for CME.
1590  {
1591  return LegSecurityIDSource();
1592  }
1593 
1594  /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
1595  /// 'product code').
1596  bool legSecurityGroup(StrRef& value) const
1597  {
1598  const BodySize offset = 58;
1599  const BodySize length = 12;
1600 
1601  return fixedStr<length>(value, offset);
1602  }
1603 
1604  /// Used to correlate leg instrument definitions with their
1605  /// executions.Cross referenced in Tag 654.
1606  bool legId(StrRef& value) const
1607  {
1608  const BodySize offset = 70;
1609  const BodySize length = 17;
1610 
1611  return fixedStr<length>(value, offset);
1612  }
1613 
1614  /// Identifies the type of leg instrument.
1615  bool legSecurityType(StrRef& value) const
1616  {
1617  const BodySize offset = 87;
1618  const BodySize length = 9;
1619 
1620  return fixedStr<length>(value, offset);
1621  }
1622 
1623  /// Multileg instrument's individual security's leg
1624  /// MaturityMonthYear.
1626  {
1627  typedef NullMaturityMonthYear Null;
1628 
1629  const BodySize offset = 96;
1630 
1631  return ordinary(value, offset, Null());
1632  }
1633 
1634  /// Multileg instrument's individual security's leg
1635  /// MaturityDate.
1636  bool legMaturityDate(Timestamp& value) const
1637  {
1638  typedef NullLocalMktDate Null;
1639  typedef LocalMktDate FieldValue;
1640 
1641  const BodySize offset = 101;
1642 
1643  FieldValue fieldValue;
1644 
1645  if (ordinary(fieldValue, offset, Null()))
1646  {
1647  value = localMktDateToTimestamp(fieldValue);
1648  return true;
1649  }
1650  return false;
1651  }
1652 
1653  /// Multileg instrument's individual security's StrikePrice.
1654  bool legStrikePrice(PRICENULL& value) const
1655  {
1656  typedef NullPRICENULL Null;
1657 
1658  const BodySize offset = 103;
1659 
1660  return ordinary(value, offset, Null());
1661  }
1662 
1663  /// Multileg instrument's individual security's leg
1664  /// UnitOfMeasure.
1665  bool legUnitOfMeasure(StrRef& value) const
1666  {
1667  const BodySize offset = 111;
1668  const BodySize length = 5;
1669 
1670  return fixedStr<length>(value, offset);
1671  }
1672 
1673  /// Multileg instrument's individual security's leg
1674  /// UnitOfMeasureQty.
1675  bool legUnitOfMeasureQty(PRICENULL& value) const
1676  {
1677  typedef NullPRICENULL Null;
1678 
1679  const BodySize offset = 116;
1680 
1681  return ordinary(value, offset, Null());
1682  }
1683 
1684  /// Multileg instrument's individual security's leg
1685  /// SecurityExchange.
1686  bool legSecurityExchange(StrRef& value) const
1687  {
1688  const BodySize offset = 124;
1689  const BodySize length = 4;
1690 
1691  return fixedStr<length>(value, offset);
1692  }
1693 
1694  /// The ratio of quantity for this individual leg relative to
1695  /// the entire multileg security.
1696  bool legRatioQty(UInt16& value) const
1697  {
1698  typedef NullUInt16 Null;
1699 
1700  const BodySize offset = 128;
1701 
1702  return ordinary(value, offset, Null());
1703  }
1704 
1705  /// The side of this individual leg (multileg security).
1706  bool legSide(UInt8& value) const
1707  {
1708  typedef NullUInt8 Null;
1709 
1710  const BodySize offset = 130;
1711 
1712  return ordinary(value, offset, Null());
1713  }
1714 
1715  /// Multileg instrument's individual security's leg option put
1716  /// or call.
1717  bool legPutOrCall(UInt8& value) const
1718  {
1719  typedef NullUInt8 Null;
1720 
1721  const BodySize offset = 131;
1722 
1723  return ordinary(value, offset, Null());
1724  }
1725 
1726  /// Indicates the currency of the unit of measure.
1727  /// Conditionally required when LegUnitOfMeasure(999) = Ccy.
1729  {
1730  const BodySize offset = 132;
1731  const BodySize length = 3;
1732 
1733  return fixedStr<length>(value, offset);
1734  }
1735 
1736  /// Returns size of entry body in bytes
1737  /// for given version of message template.
1740  {
1741  return 135;
1742  }
1743 
1744  /// Entity class name.
1746  static const Char* className()
1747  {
1748  return "Entries.LegsEntry";
1749  }
1750  };
1751 
1752  /// Repeating group containing LegsEntry entries.
1753  typedef
1756 
1757  /// Market Data update Action.
1759  {
1760  const BodySize offset = 0;
1761 
1762  return enumeration<UpdateAction>(offset);
1763  }
1764 
1765  /// Market Data Entry Type.
1767  {
1768  return EntryTypeTrade();
1769  }
1770 
1771  /// Unique security ID.
1772  bool securityId(UInt64& value) const
1773  {
1774  typedef NullUInt64 Null;
1775 
1776  const BodySize offset = 1;
1777 
1778  return ordinary(value, offset, Null());
1779  }
1780 
1781  /// MD Entry sequence number per instrument update. Reset
1782  /// weekly.
1783  UInt32 rptSeq() const
1784  {
1785  const BodySize offset = 9;
1786 
1787  return ordinary<UInt32>(offset);
1788  }
1789 
1790  /// Price of the Market Data Entry.
1791  bool entryPx(PRICENULL& value) const
1792  {
1793  typedef NullPRICENULL Null;
1794 
1795  const BodySize offset = 13;
1796 
1797  return ordinary(value, offset, Null());
1798  }
1799 
1800  /// Traded quantity.
1801  bool entrySize(UInt64& value) const
1802  {
1803  typedef NullUInt64 Null;
1804 
1805  const BodySize offset = 21;
1806 
1807  return ordinary(value, offset, Null());
1808  }
1809 
1810  /// The total number of real orders per instrument that
1811  /// participated in a match step within a match event.
1812  bool numberOfOrders(Int32& value) const
1813  {
1814  typedef NullInt32 Null;
1815 
1816  const BodySize offset = 29;
1817 
1818  return ordinary(value, offset, Null());
1819  }
1820 
1821  /// Unique Trade Entry ID per Instrument and Trading Date.
1822  Int32 tradeId() const
1823  {
1824  const BodySize offset = 33;
1825 
1826  return ordinary<Int32>(offset);
1827  }
1828 
1829  /// Indicates which side is aggressor of the trade. If there
1830  /// is no value present, then there is no aggressor.
1831  bool
1833  AggressorSide::Enum& value) const
1834  {
1835  typedef NullUInt8 Null;
1836 
1837  const BodySize offset = 37;
1838 
1839  return enumeration<AggressorSide>(value, offset, Null());
1840  }
1841 
1842  /// Instrument/Index/Swap Name.
1843  bool symbol(StrRef& value) const
1844  {
1845  const BodySize offset = 38;
1846  const BodySize length = 50;
1847 
1848  return fixedStr<length>(value, offset);
1849  }
1850 
1851  /// Indicates the product code for the instrument.
1852  bool securityGroup(StrRef& value) const
1853  {
1854  const BodySize offset = 88;
1855  const BodySize length = 12;
1856 
1857  return fixedStr<length>(value, offset);
1858  }
1859 
1860  /// Identifies the type of instrument.
1861  bool securityType(StrRef& value) const
1862  {
1863  const BodySize offset = 100;
1864  const BodySize length = 9;
1865 
1866  return fixedStr<length>(value, offset);
1867  }
1868 
1869  /// SecuritySubType for CDS only.
1870  bool securitySubType(StrRef& value) const
1871  {
1872  const BodySize offset = 109;
1873  const BodySize length = 2;
1874 
1875  return fixedStr<length>(value, offset);
1876  }
1877 
1878  /// This field provides the actual calendar date for contract
1879  /// maturity month and year (used for standardized futures and
1880  /// options).
1882  {
1883  typedef NullMaturityMonthYear Null;
1884 
1885  const BodySize offset = 111;
1886 
1887  return ordinary(value, offset, Null());
1888  }
1889 
1890  /// Market used to help identify an instrument.
1891  bool securityExchange(StrRef& value) const
1892  {
1893  const BodySize offset = 116;
1894  const BodySize length = 4;
1895 
1896  return fixedStr<length>(value, offset);
1897  }
1898 
1899  /// Maturity date of instrument.
1900  bool maturityDate(Timestamp& value) const
1901  {
1902  typedef NullLocalMktDate Null;
1903  typedef LocalMktDate FieldValue;
1904 
1905  const BodySize offset = 120;
1906 
1907  FieldValue fieldValue;
1908 
1909  if (ordinary(fieldValue, offset, Null()))
1910  {
1911  value = localMktDateToTimestamp(fieldValue);
1912  return true;
1913  }
1914  return false;
1915  }
1916 
1917  /// Unit of measure for the products' original contract size.
1918  bool unitOfMeasure(StrRef& value) const
1919  {
1920  const BodySize offset = 122;
1921  const BodySize length = 5;
1922 
1923  return fixedStr<length>(value, offset);
1924  }
1925 
1926  /// Indicates the ISO Currency code if it is a currency
1927  /// product.
1928  bool unitOfMeasureCurrency(StrRef& value) const
1929  {
1930  const BodySize offset = 127;
1931  const BodySize length = 3;
1932 
1933  return fixedStr<length>(value, offset);
1934  }
1935 
1936  /// This field contains the notional value for each
1937  /// instrument. The notional value is equivalent to the
1938  /// corresponding premium-quoted contract.
1939  bool unitOfMeasureQty(PRICENULL& value) const
1940  {
1941  typedef NullPRICENULL Null;
1942 
1943  const BodySize offset = 130;
1944 
1945  return ordinary(value, offset, Null());
1946  }
1947 
1948  /// The rate of interest that, when multiplied by the
1949  /// principal, par value, or face value of a bond, provides
1950  /// the currency amount of the periodic interest payment.
1951  bool couponRate(Decimal32& value) const
1952  {
1953  typedef NullDecimal32 Null;
1954 
1955  const BodySize offset = 138;
1956 
1957  return ordinary(value, offset, Null());
1958  }
1959 
1960  /// Valid price types for intraday trade.
1961  bool priceType(UInt16& value) const
1962  {
1963  typedef NullUInt16 Null;
1964 
1965  const BodySize offset = 142;
1966 
1967  return ordinary(value, offset, Null());
1968  }
1969 
1970  /// Valid trade types for intraday trade.
1971  bool trdType(UInt8& value) const
1972  {
1973  typedef NullUInt8 Null;
1974 
1975  const BodySize offset = 144;
1976 
1977  return ordinary(value, offset, Null());
1978  }
1979 
1980  /// Market data entry identifier to map multiple prices of a
1981  /// single trade.
1982  bool entryId(StrRef& value) const
1983  {
1984  const BodySize offset = 145;
1985  const BodySize length = 26;
1986 
1987  return fixedStr<length>(value, offset);
1988  }
1989 
1990  /// Indicates whether an option instrument is a put or call.
1991  bool putOrCall(UInt8& value) const
1992  {
1993  typedef NullUInt8 Null;
1994 
1995  const BodySize offset = 171;
1996 
1997  return ordinary(value, offset, Null());
1998  }
1999 
2000  /// Strike Price for an option instrument.
2001  bool strikePrice(PRICENULL& value) const
2002  {
2003  typedef NullPRICENULL Null;
2004 
2005  const BodySize offset = 172;
2006 
2007  return ordinary(value, offset, Null());
2008  }
2009 
2010  /// A category of CDS credit event in which the underlying
2011  /// bond experiences a restructuring.
2012  bool restructuringType(StrRef& value) const
2013  {
2014  const BodySize offset = 180;
2015  const BodySize length = 2;
2016 
2017  return fixedStr<length>(value, offset);
2018  }
2019 
2020  /// Specifies which issue (underlying bond) will receive
2021  /// payment priority in the event of a default.
2022  bool seniority(StrRef& value) const
2023  {
2024  const BodySize offset = 182;
2025  const BodySize length = 2;
2026 
2027  return fixedStr<length>(value, offset);
2028  }
2029 
2030  /// For future use.
2031  bool referenceId(StrRef& value) const
2032  {
2033  const BodySize offset = 184;
2034  const BodySize length = 100;
2035 
2036  return fixedStr<length>(value, offset);
2037  }
2038 
2039  /// Identifies the multileg strategy (e.g. spread) to which
2040  /// the trade belongs. This links together trade legs executed
2041  /// as part of a strategy during a single match event.
2042  bool strategyLinkId(StrRef& value) const
2043  {
2044  const BodySize offset = 284;
2045  const BodySize length = 26;
2046 
2047  return fixedStr<length>(value, offset);
2048  }
2049 
2050  /// Used to correlate leg instrument definitions with their
2051  /// executions. Cross referenced to Tag 1788.
2052  bool legRefId(StrRef& value) const
2053  {
2054  const BodySize offset = 310;
2055  const BodySize length = 17;
2056 
2057  return fixedStr<length>(value, offset);
2058  }
2059 
2060  /// Returns instance of Underlyings repeating group.
2062  {
2063  return
2064  groups().
2065  head<Underlyings>();
2066  }
2067 
2068  /// Returns instance of PartyIDs repeating group.
2070  {
2071  return
2072  groups().
2073  tail<Underlyings>().
2074  head<PartyIDs>();
2075  }
2076 
2077  /// Returns instance of Legs repeating group.
2078  Legs legs() const
2079  {
2080  return
2081  groups().
2082  tail<Underlyings>().
2083  tail<PartyIDs>().
2084  head<Legs>();
2085  }
2086 
2087  /// Returns size of entry body in bytes
2088  /// for given version of message template.
2091  {
2092  return 327;
2093  }
2094 
2095  /// Returns reference to the next item.
2097  {
2098  const void* body = legs().end().get().body();
2099  return Entry(
2100  body,
2101  bodySize(version()),
2102  version());
2103  }
2104 
2105  /// Entity class name.
2107  static const Char* className()
2108  {
2109  return "IncrementalRefreshTradeBlocks340.Entry";
2110  }
2111  };
2112 
2113  /// Repeating group containing Entry entries.
2114  typedef
2117 
2118  /// Initializes blank instance.
2120  {
2121  }
2122 
2123  /// Initializes instance over given memory block.
2125  const void* data,
2126  MessageSize size)
2127  : BinaryMessage(data, size)
2128  {
2129  assert(TemplateId == templateId());
2130 
2131  if (size < bodySize(version()))
2132  throwBadBinaryData(className());
2133  }
2134 
2135  /// Start of event processing time in number of nanoseconds
2136  /// since Unix epoch.
2138  {
2139  const BodySize offset = 0;
2140 
2141  return ordinary<Timestamp>(offset);
2142  }
2143 
2144  /// Bitmap field of eight Boolean type indicators reflecting
2145  /// the end of updates for a given event.
2146  const MatchEventIndicator&
2148  {
2149  const BodySize offset = 8;
2150 
2151  return ordinary<MatchEventIndicator>(offset);
2152  }
2153 
2154  /// Total number of messages contained within batch which is
2155  /// defined by match event indicator (5799).
2157  {
2158  const BodySize offset = 9;
2159 
2160  return ordinary<UInt16>(offset);
2161  }
2162 
2163  /// Returns instance of Entries repeating group.
2165  {
2166  return
2167  groups().
2168  head<Entries>();
2169  }
2170 
2171  /// Size of message body in bytes.
2174  {
2175  return 11;
2176  }
2177 
2178  /// Returns class name.
2180  static const Char* className()
2181  {
2182  return "IncrementalRefreshTradeBlocks340";
2183  }
2184 
2185  /// FIX message type.
2187  static StrRef fixType()
2188  {
2189  return toStrRef("X");
2190  }
2191 };
2192 
2193 /// QuoteRequest.
2196 : BinaryMessage
2197 {
2198  /// Message template ID from SBE schema.
2199  enum { TemplateId = 345 };
2200 
2201  /// Specifies the number of repeating symbols specified..
2202  /// Entry of RelatedSymEntry repeating group.
2205  <
2207  >
2208  {
2209  /// Aliases base class type.
2210  typedef
2212  <
2214  >
2216 
2217  /// Initializes blank instance.
2219  {
2220  }
2221 
2222  /// Initializes instance of given
2223  /// version over given memory block.
2225  const void* data,
2226  BodySize size,
2227  SchemaVersion version)
2228  : Base(data, size, version)
2229  {
2230  if (size < bodySize(version))
2231  throwBadBinaryData(className());
2232  }
2233 
2234  /// Number of repeating EventType entries..
2235  /// Entry of EventsEntry repeating group.
2238  <
2240  >
2241  {
2242  /// Aliases base class type.
2243  typedef
2245  <
2247  >
2249 
2250  /// Initializes blank instance.
2252  {
2253  }
2254 
2255  /// Initializes instance of given
2256  /// version over given memory block.
2258  const void* data,
2259  BodySize size,
2260  SchemaVersion version)
2261  : Base(data, size, version)
2262  {
2263  if (size < bodySize(version))
2264  throwBadBinaryData(className());
2265  }
2266 
2267  /// Code to represent the type of event..
2268  bool eventType(UInt8& value) const
2269  {
2270  typedef NullUInt8 Null;
2271 
2272  const BodySize offset = 0;
2273 
2274  return ordinary(value, offset, Null());
2275  }
2276 
2277  /// Time of event. This is number of days since unix epoch.
2278  bool eventTime(UInt64& value) const
2279  {
2280  typedef NullUInt64 Null;
2281 
2282  const BodySize offset = 1;
2283 
2284  return ordinary(value, offset, Null());
2285  }
2286 
2287  /// Returns size of entry body in bytes
2288  /// for given version of message template.
2291  {
2292  return 9;
2293  }
2294 
2295  /// Entity class name.
2297  static const Char* className()
2298  {
2299  return "RelatedSym.EventsEntry";
2300  }
2301  };
2302 
2303  /// Repeating group containing EventsEntry entries.
2304  typedef
2307 
2308  /// Instrument/Index/Swap Name.
2309  bool symbol(StrRef& value) const
2310  {
2311  const BodySize offset = 0;
2312  const BodySize length = 50;
2313 
2314  return fixedStr<length>(value, offset);
2315  }
2316 
2317  /// Coupon Rate of the swap.
2318  bool couponRate(Decimal32& value) const
2319  {
2320  typedef NullDecimal32 Null;
2321 
2322  const BodySize offset = 50;
2323 
2324  return ordinary(value, offset, Null());
2325  }
2326 
2327  /// Quantity Requested.
2328  bool orderQty(UInt64& value) const
2329  {
2330  typedef NullUInt64 Null;
2331 
2332  const BodySize offset = 54;
2333 
2334  return ordinary(value, offset, Null());
2335  }
2336 
2337  /// Market used to help identify an instrument.
2339  {
2340  const BodySize offset = 62;
2341  const BodySize length = 4;
2342 
2343  return fixedStr<length>(offset);
2344  }
2345 
2346  /// Indicates the type of product the instrument is associated
2347  /// with in the message.
2348  bool product(UInt8& value) const
2349  {
2350  typedef NullUInt8 Null;
2351 
2352  const BodySize offset = 66;
2353 
2354  return ordinary(value, offset, Null());
2355  }
2356 
2357  /// Indicates the product code for the instrument.
2358  bool securityGroup(StrRef& value) const
2359  {
2360  const BodySize offset = 67;
2361  const BodySize length = 26;
2362 
2363  return fixedStr<length>(value, offset);
2364  }
2365 
2366  /// Maturity date of instrument.
2367  bool maturityDate(Timestamp& value) const
2368  {
2369  typedef NullLocalMktDate Null;
2370  typedef LocalMktDate FieldValue;
2371 
2372  const BodySize offset = 93;
2373 
2374  FieldValue fieldValue;
2375 
2376  if (ordinary(fieldValue, offset, Null()))
2377  {
2378  value = localMktDateToTimestamp(fieldValue);
2379  return true;
2380  }
2381  return false;
2382  }
2383 
2384  /// Indicates type of instrument.
2385  bool securityType(StrRef& value) const
2386  {
2387  const BodySize offset = 95;
2388  const BodySize length = 4;
2389 
2390  return fixedStr<length>(value, offset);
2391  }
2392 
2393  /// Type of quote requested. A tradable quote can trade
2394  /// against other orders and quotes upon acceptance.
2395  bool quoteType(UInt8& value) const
2396  {
2397  typedef NullUInt8 Null;
2398 
2399  const BodySize offset = 99;
2400 
2401  return ordinary(value, offset, Null());
2402  }
2403 
2404  /// Returns instance of Events repeating group.
2405  Events events() const
2406  {
2407  return
2408  groups().
2409  head<Events>();
2410  }
2411 
2412  /// Returns size of entry body in bytes
2413  /// for given version of message template.
2416  {
2417  return 100;
2418  }
2419 
2420  /// Returns reference to the next item.
2422  {
2423  const void* body = events().end().get().body();
2424  return RelatedSymEntry(
2425  body,
2426  bodySize(version()),
2427  version());
2428  }
2429 
2430  /// Entity class name.
2432  static const Char* className()
2433  {
2434  return "QuoteRequest345.RelatedSymEntry";
2435  }
2436  };
2437 
2438  /// Repeating group containing RelatedSymEntry entries.
2439  typedef
2442 
2443  /// Initializes blank instance.
2445  {
2446  }
2447 
2448  /// Initializes instance over given memory block.
2450  const void* data,
2451  MessageSize size)
2452  : BinaryMessage(data, size)
2453  {
2454  assert(TemplateId == templateId());
2455 
2456  if (size < bodySize(version()))
2457  throwBadBinaryData(className());
2458  }
2459 
2460  /// Time of quote request creation, expressed in UTC.
2462  {
2463  const BodySize offset = 0;
2464 
2465  return ordinary<Timestamp>(offset);
2466  }
2467 
2468  /// Bitmap field of eight Boolean type indicators reflecting
2469  /// the end of updates for a given Globex event.
2470  const MatchEventIndicator&
2472  {
2473  const BodySize offset = 8;
2474 
2475  return ordinary<MatchEventIndicator>(offset);
2476  }
2477 
2478  /// Quote request ID defined by the exchange.
2479  bool quoteReqId(StrRef& value) const
2480  {
2481  const BodySize offset = 9;
2482  const BodySize length = 26;
2483 
2484  return fixedStr<length>(value, offset);
2485  }
2486 
2487  /// Returns instance of RelatedSym repeating group.
2489  {
2490  return
2491  groups().
2492  head<RelatedSym>();
2493  }
2494 
2495  /// Size of message body in bytes.
2498  {
2499  return 35;
2500  }
2501 
2502  /// Returns class name.
2504  static const Char* className()
2505  {
2506  return "QuoteRequest345";
2507  }
2508 
2509  /// FIX message type.
2511  static StrRef fixType()
2512  {
2513  return toStrRef("R");
2514  }
2515 };
2516 
2517 /// MDInstrumentDefinitionIndices.
2520 : BinaryMessage
2521 {
2522  /// Message template ID from SBE schema.
2523  enum { TemplateId = 347 };
2524 
2525  /// Number of repeating InstrAttribType entries..
2526  /// Entry of InstAttribEntry repeating group.
2529  <
2531  >
2532  {
2533  /// Aliases base class type.
2534  typedef
2536  <
2538  >
2540 
2541  /// Initializes blank instance.
2543  {
2544  }
2545 
2546  /// Initializes instance of given
2547  /// version over given memory block.
2549  const void* data,
2550  BodySize size,
2551  SchemaVersion version)
2552  : Base(data, size, version)
2553  {
2554  if (size < bodySize(version))
2555  throwBadBinaryData(className());
2556  }
2557 
2558  /// Code to represent the type of instrument attribute.
2560  {
2561  const BodySize offset = 0;
2562 
2563  return ordinary<UInt8>(offset);
2564  }
2565 
2566  /// Attribute value appropriate to the InstrAttribType (871)
2567  /// field.
2568  bool instAttribValue(StrRef& value) const
2569  {
2570  const BodySize offset = 1;
2571  const BodySize length = 100;
2572 
2573  return fixedStr<length>(value, offset);
2574  }
2575 
2576  /// Returns size of entry body in bytes
2577  /// for given version of message template.
2580  {
2581  return 101;
2582  }
2583 
2584  /// Entity class name.
2586  static const Char* className()
2587  {
2588  return "InstrumentDefinitionIndices347.InstAttribEntry";
2589  }
2590  };
2591 
2592  /// Repeating group containing InstAttribEntry entries.
2593  typedef
2596 
2597  /// Number of repeating EventType entries..
2598  /// Entry of EventsEntry repeating group.
2601  <
2603  >
2604  {
2605  /// Aliases base class type.
2606  typedef
2608  <
2610  >
2612 
2613  /// Initializes blank instance.
2615  {
2616  }
2617 
2618  /// Initializes instance of given
2619  /// version over given memory block.
2621  const void* data,
2622  BodySize size,
2623  SchemaVersion version)
2624  : Base(data, size, version)
2625  {
2626  if (size < bodySize(version))
2627  throwBadBinaryData(className());
2628  }
2629 
2630  /// Code to represent the type of event.
2632  {
2633  const BodySize offset = 0;
2634 
2635  return enumeration<EventTypeIndices>(offset);
2636  }
2637 
2638  /// Time of event. This is number of days since unix epoch.
2640  {
2641  const BodySize offset = 1;
2642 
2643  return ordinary<UInt64>(offset);
2644  }
2645 
2646  /// Returns size of entry body in bytes
2647  /// for given version of message template.
2650  {
2651  return 9;
2652  }
2653 
2654  /// Entity class name.
2656  static const Char* className()
2657  {
2658  return "InstrumentDefinitionIndices347.EventsEntry";
2659  }
2660  };
2661 
2662  /// Repeating group containing EventsEntry entries.
2663  typedef
2666 
2667  /// Initializes blank instance.
2669  {
2670  }
2671 
2672  /// Initializes instance over given memory block.
2674  const void* data,
2675  MessageSize size)
2676  : BinaryMessage(data, size)
2677  {
2678  assert(TemplateId == templateId());
2679 
2680  if (size < bodySize(version()))
2681  throwBadBinaryData(className());
2682  }
2683 
2684  /// Instrument Name or Symbol.
2685  bool symbol(StrRef& value) const
2686  {
2687  const BodySize offset = 0;
2688  const BodySize length = 50;
2689 
2690  return fixedStr<length>(value, offset);
2691  }
2692 
2693  /// Indicates the type of product the instrument is associated
2694  /// with in the message.
2695  Int8 product() const
2696  {
2697  const BodySize offset = 50;
2698 
2699  return ordinary<Int8>(offset);
2700  }
2701 
2702  /// Market used to help identify an instrument.
2704  {
2705  const BodySize offset = 51;
2706  const BodySize length = 4;
2707 
2708  return fixedStr<length>(offset);
2709  }
2710 
2711  /// Identifies the currency for the instrument traded.
2713  {
2714  const BodySize offset = 55;
2715  const BodySize length = 3;
2716 
2717  return fixedStr<length>(offset);
2718  }
2719 
2720  /// Included on the message when a modification or deletion
2721  /// occurs.
2724  {
2725  const BodySize offset = 58;
2726 
2727  return enumeration<SecurityUpdateAction>(offset);
2728  }
2729 
2730  /// Describes a class of service for a given data feed.
2731  bool feedType(StrRef& value) const
2732  {
2733  const BodySize offset = 59;
2734  const BodySize length = 2;
2735 
2736  return fixedStr<length>(value, offset);
2737  }
2738 
2739  /// This value indicates the channel ID as defined in the XML
2740  /// configuration file.
2741  bool applId(UInt16& value) const
2742  {
2743  typedef NullUInt16 Null;
2744 
2745  const BodySize offset = 61;
2746 
2747  return ordinary(value, offset, Null());
2748  }
2749 
2750  /// Returns instance of InstAttrib repeating group.
2752  {
2753  return
2754  groups().
2755  head<InstAttrib>();
2756  }
2757 
2758  /// Returns instance of Events repeating group.
2759  Events events() const
2760  {
2761  return
2762  groups().
2763  tail<InstAttrib>().
2764  head<Events>();
2765  }
2766 
2767  /// Size of message body in bytes.
2770  {
2771  return 63;
2772  }
2773 
2774  /// Returns class name.
2776  static const Char* className()
2777  {
2778  return "InstrumentDefinitionIndices347";
2779  }
2780 
2781  /// FIX message type.
2783  static StrRef fixType()
2784  {
2785  return toStrRef("d");
2786  }
2787 };
2788 
2789 /// MDIncrementalRefreshIndices.
2792 : BinaryMessage
2793 {
2794  /// Message template ID from SBE schema.
2795  enum { TemplateId = 348 };
2796 
2797  /// Number of entries in Market Data message.
2798  /// Entry of Entry repeating group.
2801  <
2803  >
2804  {
2805  /// Aliases base class type.
2806  typedef
2808  <
2810  >
2812 
2813  /// Initializes blank instance.
2815  {
2816  }
2817 
2818  /// Initializes instance of given
2819  /// version over given memory block.
2821  const void* data,
2822  BodySize size,
2823  SchemaVersion version)
2824  : Base(data, size, version)
2825  {
2826  if (size < bodySize(version))
2827  throwBadBinaryData(className());
2828  }
2829 
2830  /// Indicates Market data Update Action which is always New.
2832  {
2833  return UpdateActionNew();
2834  }
2835 
2836  /// Indicates Market Data Entry Type.
2838  {
2839  const BodySize offset = 0;
2840 
2841  return enumeration<EntryTypeIndices>(offset);
2842  }
2843 
2844  /// MD Entry sequence number per index update.
2845  UInt32 rptSeq() const
2846  {
2847  const BodySize offset = 1;
2848 
2849  return ordinary<UInt32>(offset);
2850  }
2851 
2852  /// Price of the Market Data Entry.
2854  {
2855  const BodySize offset = 5;
2856 
2857  return ordinary<Decimal64>(offset);
2858  }
2859 
2860  /// Quantity of the MD Entry.
2861  bool entrySize(UInt64& value) const
2862  {
2863  typedef NullUInt64 Null;
2864 
2865  const BodySize offset = 14;
2866 
2867  return ordinary(value, offset, Null());
2868  }
2869 
2870  /// Index Name.
2871  bool symbol(StrRef& value) const
2872  {
2873  const BodySize offset = 22;
2874  const BodySize length = 50;
2875 
2876  return fixedStr<length>(value, offset);
2877  }
2878 
2879  /// Indicates whether the price is preliminary or previous day.
2880  bool openCloseSettlFlag(Int8& value) const
2881  {
2882  typedef NullInt8 Null;
2883 
2884  const BodySize offset = 72;
2885 
2886  return ordinary(value, offset, Null());
2887  }
2888 
2889  /// Type of yield.
2890  bool yieldType(StrRef& value) const
2891  {
2892  const BodySize offset = 73;
2893  const BodySize length = 8;
2894 
2895  return fixedStr<length>(value, offset);
2896  }
2897 
2898  /// Yield of the index's underlying constituents and
2899  /// applicable for FI indices only.
2901  {
2902  const BodySize offset = 81;
2903 
2904  return ordinary<Decimal64>(offset);
2905  }
2906 
2907  /// Net change from previous day's closing price.
2909  {
2910  const BodySize offset = 90;
2911 
2912  return ordinary<Decimal64>(offset);
2913  }
2914 
2915  /// Index percentage change with respect to previous close.
2917  {
2918  const BodySize offset = 99;
2919 
2920  return ordinary<Decimal64>(offset);
2921  }
2922 
2923  /// Percent trading of the underlying index constituents.
2925  {
2926  const BodySize offset = 108;
2927 
2928  return ordinary<Decimal64>(offset);
2929  }
2930 
2931  /// List of conditions describing a index value.
2932  bool entryCode(EntryCode::Enum& value) const
2933  {
2934  typedef NullUInt8 Null;
2935 
2936  const BodySize offset = 117;
2937 
2938  return enumeration<EntryCode>(value, offset, Null());
2939  }
2940 
2941  /// Indicates Market Data Entry Date.
2942  bool entryDate(Int32& value) const
2943  {
2944  typedef NullInt32 Null;
2945 
2946  const BodySize offset = 118;
2947 
2948  return ordinary(value, offset, Null());
2949  }
2950 
2951  /// Indicates Market Data Entry Timestamp.
2952  bool entryTime(Int32& value) const
2953  {
2954  typedef NullInt32 Null;
2955 
2956  const BodySize offset = 122;
2957 
2958  return ordinary(value, offset, Null());
2959  }
2960 
2961  /// For future use.
2962  bool referenceId(StrRef& value) const
2963  {
2964  const BodySize offset = 126;
2965  const BodySize length = 50;
2966 
2967  return fixedStr<length>(value, offset);
2968  }
2969 
2970  /// Returns size of entry body in bytes
2971  /// for given version of message template.
2974  {
2975  return 176;
2976  }
2977 
2978  /// Entity class name.
2980  static const Char* className()
2981  {
2982  return "IncrementalRefreshIndices348.Entry";
2983  }
2984  };
2985 
2986  /// Repeating group containing Entry entries.
2987  typedef
2990 
2991  /// Initializes blank instance.
2993  {
2994  }
2995 
2996  /// Initializes instance over given memory block.
2998  const void* data,
2999  MessageSize size)
3000  : BinaryMessage(data, size)
3001  {
3002  assert(TemplateId == templateId());
3003 
3004  if (size < bodySize(version()))
3005  throwBadBinaryData(className());
3006  }
3007 
3008  /// Start of event processing time in number of nanoseconds
3009  /// since epoch.
3011  {
3012  const BodySize offset = 0;
3013 
3014  return ordinary<Timestamp>(offset);
3015  }
3016 
3017  /// Describes a class of service for a given data feed.
3018  bool feedType(StrRef& value) const
3019  {
3020  const BodySize offset = 8;
3021  const BodySize length = 2;
3022 
3023  return fixedStr<length>(value, offset);
3024  }
3025 
3026  /// Bitmap field of eight Boolean type indicators reflecting
3027  /// the end of updates for a given event.
3028  const MatchEventIndicator&
3030  {
3031  const BodySize offset = 10;
3032 
3033  return ordinary<MatchEventIndicator>(offset);
3034  }
3035 
3036  /// Total number of messages contained within batch which is
3037  /// defined by match event indicator (5799).
3038  bool batchTotalMessages(UInt16& value) const
3039  {
3040  typedef NullUInt16 Null;
3041 
3042  const BodySize offset = 11;
3043 
3044  return ordinary(value, offset, Null());
3045  }
3046 
3047  /// Returns instance of Entries repeating group.
3049  {
3050  return
3051  groups().
3052  head<Entries>();
3053  }
3054 
3055  /// Size of message body in bytes.
3058  {
3059  return 13;
3060  }
3061 
3062  /// Returns class name.
3064  static const Char* className()
3065  {
3066  return "IncrementalRefreshIndices348";
3067  }
3068 
3069  /// FIX message type.
3071  static StrRef fixType()
3072  {
3073  return toStrRef("X");
3074  }
3075 };
3076 
3077 /// MDIncrementalRefreshTradeBlocks.
3080 : BinaryMessage
3081 {
3082  /// Message template ID from SBE schema.
3083  enum { TemplateId = 349 };
3084 
3085  /// Number of entries in Market Data message..
3086  /// Entry of Entry repeating group.
3089  <
3091  >
3092  {
3093  /// Aliases base class type.
3094  typedef
3096  <
3098  >
3100 
3101  /// Initializes blank instance.
3103  {
3104  }
3105 
3106  /// Initializes instance of given
3107  /// version over given memory block.
3109  const void* data,
3110  BodySize size,
3111  SchemaVersion version)
3112  : Base(data, size, version)
3113  {
3114  if (size < bodySize(version))
3115  throwBadBinaryData(className());
3116  }
3117 
3118  /// Number of underlying legs that make up the security.
3119  /// Entry of UnderlyingsEntry repeating group.
3122  <
3124  >
3125  {
3126  /// Aliases base class type.
3127  typedef
3129  <
3131  >
3133 
3134  /// Initializes blank instance.
3136  {
3137  }
3138 
3139  /// Initializes instance of given
3140  /// version over given memory block.
3142  const void* data,
3143  BodySize size,
3144  SchemaVersion version)
3145  : Base(data, size, version)
3146  {
3147  if (size < bodySize(version))
3148  throwBadBinaryData(className());
3149  }
3150 
3151  /// Underlying Security's symbol.
3152  bool underlyingSymbol(StrRef& value) const
3153  {
3154  const BodySize offset = 0;
3155  const BodySize length = 50;
3156 
3157  return fixedStr<length>(value, offset);
3158  }
3159 
3160  /// Underlying Security's MaturityMonthYear.
3162  {
3163  typedef NullMaturityMonthYear Null;
3164 
3165  const BodySize offset = 50;
3166 
3167  return ordinary(value, offset, Null());
3168  }
3169 
3170  /// Underlying Security's SecurityType.
3171  bool underlyingSecurityType(StrRef& value) const
3172  {
3173  const BodySize offset = 55;
3174  const BodySize length = 9;
3175 
3176  return fixedStr<length>(value, offset);
3177  }
3178 
3179  /// Underlying Security's SecurityExchange.
3181  {
3182  const BodySize offset = 64;
3183  const BodySize length = 4;
3184 
3185  return fixedStr<length>(value, offset);
3186  }
3187 
3188  /// Returns size of entry body in bytes
3189  /// for given version of message template.
3192  {
3193  return 68;
3194  }
3195 
3196  /// Entity class name.
3198  static const Char* className()
3199  {
3200  return "Entries.UnderlyingsEntry";
3201  }
3202  };
3203 
3204  /// Repeating group containing UnderlyingsEntry entries.
3205  typedef
3208 
3209  /// Number of party roles.
3210  /// Entry of PartyIDsEntry repeating group.
3213  <
3215  >
3216  {
3217  /// Aliases base class type.
3218  typedef
3220  <
3222  >
3224 
3225  /// Initializes blank instance.
3227  {
3228  }
3229 
3230  /// Initializes instance of given
3231  /// version over given memory block.
3233  const void* data,
3234  BodySize size,
3235  SchemaVersion version)
3236  : Base(data, size, version)
3237  {
3238  if (size < bodySize(version))
3239  throwBadBinaryData(className());
3240  }
3241 
3242  /// Party identifier/code.
3243  bool partyId(StrRef& value) const
3244  {
3245  const BodySize offset = 0;
3246  const BodySize length = 50;
3247 
3248  return fixedStr<length>(value, offset);
3249  }
3250 
3251  /// Identifies the type or role of the PartyID specified.
3252  bool partyRole(StrRef& value) const
3253  {
3254  const BodySize offset = 50;
3255  const BodySize length = 2;
3256 
3257  return fixedStr<length>(value, offset);
3258  }
3259 
3260  /// Returns size of entry body in bytes
3261  /// for given version of message template.
3264  {
3265  return 52;
3266  }
3267 
3268  /// Entity class name.
3270  static const Char* className()
3271  {
3272  return "Entries.PartyIDsEntry";
3273  }
3274  };
3275 
3276  /// Repeating group containing PartyIDsEntry entries.
3277  typedef
3280 
3281  /// Number of legs (repeating groups).
3282  /// Entry of LegsEntry repeating group.
3285  <
3287  >
3288  {
3289  /// Aliases base class type.
3290  typedef
3292  <
3294  >
3296 
3297  /// Initializes blank instance.
3299  {
3300  }
3301 
3302  /// Initializes instance of given
3303  /// version over given memory block.
3305  const void* data,
3306  BodySize size,
3307  SchemaVersion version)
3308  : Base(data, size, version)
3309  {
3310  if (size < bodySize(version))
3311  throwBadBinaryData(className());
3312  }
3313 
3314  /// This tag contains the instrument group of the requested
3315  /// security definition. Must be present when tag 555-NoLegs
3316  /// is present. Also must be first tag in repeating group.
3317  /// Multileg instrument's individual security's Symbol.
3318  bool legSymbol(StrRef& value) const
3319  {
3320  const BodySize offset = 0;
3321  const BodySize length = 50;
3322 
3323  return fixedStr<length>(value, offset);
3324  }
3325 
3326  /// Multileg instrument's individual security's SecurityID.
3327  bool legSecurityId(UInt64& value) const
3328  {
3329  typedef NullUInt64 Null;
3330 
3331  const BodySize offset = 50;
3332 
3333  return ordinary(value, offset, Null());
3334  }
3335 
3336  /// Identifies source of tag 602-LegSecurityID value. This
3337  /// value is always 'H' for CME.
3339  {
3340  return LegSecurityIDSource();
3341  }
3342 
3343  /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
3344  /// 'product code').
3345  bool legSecurityGroup(StrRef& value) const
3346  {
3347  const BodySize offset = 58;
3348  const BodySize length = 12;
3349 
3350  return fixedStr<length>(value, offset);
3351  }
3352 
3353  /// Used to correlate leg instrument definitions with their
3354  /// executions.Cross referenced in Tag 654.
3355  bool legId(StrRef& value) const
3356  {
3357  const BodySize offset = 70;
3358  const BodySize length = 17;
3359 
3360  return fixedStr<length>(value, offset);
3361  }
3362 
3363  /// Identifies the type of leg instrument.
3364  bool legSecurityType(StrRef& value) const
3365  {
3366  const BodySize offset = 87;
3367  const BodySize length = 9;
3368 
3369  return fixedStr<length>(value, offset);
3370  }
3371 
3372  /// Multileg instrument's individual security's leg
3373  /// MaturityMonthYear.
3375  {
3376  typedef NullMaturityMonthYear Null;
3377 
3378  const BodySize offset = 96;
3379 
3380  return ordinary(value, offset, Null());
3381  }
3382 
3383  /// Multileg instrument's individual security's leg
3384  /// MaturityDate.
3385  bool legMaturityDate(Timestamp& value) const
3386  {
3387  typedef NullLocalMktDate Null;
3388  typedef LocalMktDate FieldValue;
3389 
3390  const BodySize offset = 101;
3391 
3392  FieldValue fieldValue;
3393 
3394  if (ordinary(fieldValue, offset, Null()))
3395  {
3396  value = localMktDateToTimestamp(fieldValue);
3397  return true;
3398  }
3399  return false;
3400  }
3401 
3402  /// Multileg instrument's individual security's StrikePrice.
3403  bool legStrikePrice(PRICENULL& value) const
3404  {
3405  typedef NullPRICENULL Null;
3406 
3407  const BodySize offset = 103;
3408 
3409  return ordinary(value, offset, Null());
3410  }
3411 
3412  /// Multileg instrument's individual security's leg
3413  /// UnitOfMeasure.
3414  bool legUnitOfMeasure(StrRef& value) const
3415  {
3416  const BodySize offset = 111;
3417  const BodySize length = 5;
3418 
3419  return fixedStr<length>(value, offset);
3420  }
3421 
3422  /// Multileg instrument's individual security's leg
3423  /// UnitOfMeasureQty.
3424  bool legUnitOfMeasureQty(PRICENULL& value) const
3425  {
3426  typedef NullPRICENULL Null;
3427 
3428  const BodySize offset = 116;
3429 
3430  return ordinary(value, offset, Null());
3431  }
3432 
3433  /// Multileg instrument's individual security's leg
3434  /// SecurityExchange.
3435  bool legSecurityExchange(StrRef& value) const
3436  {
3437  const BodySize offset = 124;
3438  const BodySize length = 4;
3439 
3440  return fixedStr<length>(value, offset);
3441  }
3442 
3443  /// The ratio of quantity for this individual leg relative to
3444  /// the entire multileg security.
3445  bool legRatioQty(UInt16& value) const
3446  {
3447  typedef NullUInt16 Null;
3448 
3449  const BodySize offset = 128;
3450 
3451  return ordinary(value, offset, Null());
3452  }
3453 
3454  /// The side of this individual leg (multileg security).
3455  bool legSide(UInt8& value) const
3456  {
3457  typedef NullUInt8 Null;
3458 
3459  const BodySize offset = 130;
3460 
3461  return ordinary(value, offset, Null());
3462  }
3463 
3464  /// Multileg instrument's individual security's leg option put
3465  /// or call.
3466  bool legPutOrCall(UInt8& value) const
3467  {
3468  typedef NullUInt8 Null;
3469 
3470  const BodySize offset = 131;
3471 
3472  return ordinary(value, offset, Null());
3473  }
3474 
3475  /// Indicates the currency of the unit of measure.
3476  /// Conditionally required when LegUnitOfMeasure(999) = Ccy.
3478  {
3479  const BodySize offset = 132;
3480  const BodySize length = 3;
3481 
3482  return fixedStr<length>(value, offset);
3483  }
3484 
3485  /// Returns size of entry body in bytes
3486  /// for given version of message template.
3489  {
3490  return 135;
3491  }
3492 
3493  /// Entity class name.
3495  static const Char* className()
3496  {
3497  return "Entries.LegsEntry";
3498  }
3499  };
3500 
3501  /// Repeating group containing LegsEntry entries.
3502  typedef
3505 
3506  /// Market Data update Action.
3508  {
3509  const BodySize offset = 0;
3510 
3511  return enumeration<UpdateAction>(offset);
3512  }
3513 
3514  /// Market Data Entry Type.
3516  {
3517  return EntryTypeTrade();
3518  }
3519 
3520  /// Unique security ID.
3521  bool securityId(UInt64& value) const
3522  {
3523  typedef NullUInt64 Null;
3524 
3525  const BodySize offset = 1;
3526 
3527  return ordinary(value, offset, Null());
3528  }
3529 
3530  /// MD Entry sequence number per instrument update. Reset
3531  /// weekly.
3532  UInt32 rptSeq() const
3533  {
3534  const BodySize offset = 9;
3535 
3536  return ordinary<UInt32>(offset);
3537  }
3538 
3539  /// Price of the Market Data Entry.
3540  bool entryPx(PRICENULL& value) const
3541  {
3542  typedef NullPRICENULL Null;
3543 
3544  const BodySize offset = 13;
3545 
3546  return ordinary(value, offset, Null());
3547  }
3548 
3549  /// Traded quantity.
3551  {
3552  const BodySize offset = 21;
3553 
3554  return ordinary<Decimal64>(offset);
3555  }
3556 
3557  /// The total number of real orders per instrument that
3558  /// participated in a match step within a match event.
3559  bool numberOfOrders(Int32& value) const
3560  {
3561  typedef NullInt32 Null;
3562 
3563  const BodySize offset = 30;
3564 
3565  return ordinary(value, offset, Null());
3566  }
3567 
3568  /// Unique Trade Entry ID per Instrument and Trading Date.
3569  Int32 tradeId() const
3570  {
3571  const BodySize offset = 34;
3572 
3573  return ordinary<Int32>(offset);
3574  }
3575 
3576  /// Indicates which side is aggressor of the trade. If there
3577  /// is no value present, then there is no aggressor.
3578  bool
3580  AggressorSide::Enum& value) const
3581  {
3582  typedef NullUInt8 Null;
3583 
3584  const BodySize offset = 38;
3585 
3586  return enumeration<AggressorSide>(value, offset, Null());
3587  }
3588 
3589  /// Instrument/Index/Swap Name.
3590  bool symbol(StrRef& value) const
3591  {
3592  const BodySize offset = 39;
3593  const BodySize length = 50;
3594 
3595  return fixedStr<length>(value, offset);
3596  }
3597 
3598  /// Indicates the product code for the instrument.
3599  bool securityGroup(StrRef& value) const
3600  {
3601  const BodySize offset = 89;
3602  const BodySize length = 12;
3603 
3604  return fixedStr<length>(value, offset);
3605  }
3606 
3607  /// Identifies the type of instrument.
3608  bool securityType(StrRef& value) const
3609  {
3610  const BodySize offset = 101;
3611  const BodySize length = 9;
3612 
3613  return fixedStr<length>(value, offset);
3614  }
3615 
3616  /// SecuritySubType for CDS only.
3617  bool securitySubType(StrRef& value) const
3618  {
3619  const BodySize offset = 110;
3620  const BodySize length = 2;
3621 
3622  return fixedStr<length>(value, offset);
3623  }
3624 
3625  /// This field provides the actual calendar date for contract
3626  /// maturity month and year (used for standardized futures and
3627  /// options).
3629  {
3630  typedef NullMaturityMonthYear Null;
3631 
3632  const BodySize offset = 112;
3633 
3634  return ordinary(value, offset, Null());
3635  }
3636 
3637  /// Market used to help identify an instrument.
3638  bool securityExchange(StrRef& value) const
3639  {
3640  const BodySize offset = 117;
3641  const BodySize length = 4;
3642 
3643  return fixedStr<length>(value, offset);
3644  }
3645 
3646  /// Maturity date of instrument.
3647  bool maturityDate(Timestamp& value) const
3648  {
3649  typedef NullLocalMktDate Null;
3650  typedef LocalMktDate FieldValue;
3651 
3652  const BodySize offset = 121;
3653 
3654  FieldValue fieldValue;
3655 
3656  if (ordinary(fieldValue, offset, Null()))
3657  {
3658  value = localMktDateToTimestamp(fieldValue);
3659  return true;
3660  }
3661  return false;
3662  }
3663 
3664  /// Unit of measure for the products' original contract size.
3665  bool unitOfMeasure(StrRef& value) const
3666  {
3667  const BodySize offset = 123;
3668  const BodySize length = 5;
3669 
3670  return fixedStr<length>(value, offset);
3671  }
3672 
3673  /// Indicates the ISO Currency code if it is a currency
3674  /// product.
3675  bool unitOfMeasureCurrency(StrRef& value) const
3676  {
3677  const BodySize offset = 128;
3678  const BodySize length = 3;
3679 
3680  return fixedStr<length>(value, offset);
3681  }
3682 
3683  /// This field contains the notional value for each
3684  /// instrument. The notional value is equivalent to the
3685  /// corresponding premium-quoted contract.
3686  bool unitOfMeasureQty(PRICENULL& value) const
3687  {
3688  typedef NullPRICENULL Null;
3689 
3690  const BodySize offset = 131;
3691 
3692  return ordinary(value, offset, Null());
3693  }
3694 
3695  /// The rate of interest that, when multiplied by the
3696  /// principal, par value, or face value of a bond, provides
3697  /// the currency amount of the periodic interest payment.
3698  bool couponRate(Decimal32& value) const
3699  {
3700  typedef NullDecimal32 Null;
3701 
3702  const BodySize offset = 139;
3703 
3704  return ordinary(value, offset, Null());
3705  }
3706 
3707  /// Valid price types for intraday trade.
3708  bool priceType(UInt16& value) const
3709  {
3710  typedef NullUInt16 Null;
3711 
3712  const BodySize offset = 143;
3713 
3714  return ordinary(value, offset, Null());
3715  }
3716 
3717  /// Valid trade types for intraday trade.
3718  bool trdType(UInt8& value) const
3719  {
3720  typedef NullUInt8 Null;
3721 
3722  const BodySize offset = 145;
3723 
3724  return ordinary(value, offset, Null());
3725  }
3726 
3727  /// Market data entry identifier to map multiple prices of a
3728  /// single trade.
3729  bool entryId(StrRef& value) const
3730  {
3731  const BodySize offset = 146;
3732  const BodySize length = 26;
3733 
3734  return fixedStr<length>(value, offset);
3735  }
3736 
3737  /// Indicates whether an option instrument is a put or call.
3738  bool putOrCall(UInt8& value) const
3739  {
3740  typedef NullUInt8 Null;
3741 
3742  const BodySize offset = 172;
3743 
3744  return ordinary(value, offset, Null());
3745  }
3746 
3747  /// Strike Price for an option instrument.
3748  bool strikePrice(PRICENULL& value) const
3749  {
3750  typedef NullPRICENULL Null;
3751 
3752  const BodySize offset = 173;
3753 
3754  return ordinary(value, offset, Null());
3755  }
3756 
3757  /// A category of CDS credit event in which the underlying
3758  /// bond experiences a restructuring.
3759  bool restructuringType(StrRef& value) const
3760  {
3761  const BodySize offset = 181;
3762  const BodySize length = 2;
3763 
3764  return fixedStr<length>(value, offset);
3765  }
3766 
3767  /// Specifies which issue (underlying bond) will receive
3768  /// payment priority in the event of a default.
3769  bool seniority(StrRef& value) const
3770  {
3771  const BodySize offset = 183;
3772  const BodySize length = 2;
3773 
3774  return fixedStr<length>(value, offset);
3775  }
3776 
3777  /// For future use.
3778  bool referenceId(StrRef& value) const
3779  {
3780  const BodySize offset = 185;
3781  const BodySize length = 100;
3782 
3783  return fixedStr<length>(value, offset);
3784  }
3785 
3786  /// Identifies the multileg strategy (e.g. spread) to which
3787  /// the trade belongs. This links together trade legs executed
3788  /// as part of a strategy during a single match event.
3789  bool strategyLinkId(StrRef& value) const
3790  {
3791  const BodySize offset = 285;
3792  const BodySize length = 26;
3793 
3794  return fixedStr<length>(value, offset);
3795  }
3796 
3797  /// Used to correlate leg instrument definitions with their
3798  /// executions. Cross referenced to Tag 1788.
3799  bool legRefId(StrRef& value) const
3800  {
3801  const BodySize offset = 311;
3802  const BodySize length = 17;
3803 
3804  return fixedStr<length>(value, offset);
3805  }
3806 
3807  /// Returns instance of Underlyings repeating group.
3809  {
3810  return
3811  groups().
3812  head<Underlyings>();
3813  }
3814 
3815  /// Returns instance of PartyIDs repeating group.
3817  {
3818  return
3819  groups().
3820  tail<Underlyings>().
3821  head<PartyIDs>();
3822  }
3823 
3824  /// Returns instance of Legs repeating group.
3825  Legs legs() const
3826  {
3827  return
3828  groups().
3829  tail<Underlyings>().
3830  tail<PartyIDs>().
3831  head<Legs>();
3832  }
3833 
3834  /// Returns size of entry body in bytes
3835  /// for given version of message template.
3838  {
3839  return 328;
3840  }
3841 
3842  /// Returns reference to the next item.
3844  {
3845  const void* body = legs().end().get().body();
3846  return Entry(
3847  body,
3848  bodySize(version()),
3849  version());
3850  }
3851 
3852  /// Entity class name.
3854  static const Char* className()
3855  {
3856  return "IncrementalRefreshTradeBlocks349.Entry";
3857  }
3858  };
3859 
3860  /// Repeating group containing Entry entries.
3861  typedef
3864 
3865  /// Initializes blank instance.
3867  {
3868  }
3869 
3870  /// Initializes instance over given memory block.
3872  const void* data,
3873  MessageSize size)
3874  : BinaryMessage(data, size)
3875  {
3876  assert(TemplateId == templateId());
3877 
3878  if (size < bodySize(version()))
3879  throwBadBinaryData(className());
3880  }
3881 
3882  /// Start of event processing time in number of nanoseconds
3883  /// since Unix epoch. Not present for EFP (828=2) and EFR
3884  /// (828=11) transactions.
3885  bool transactTime(Timestamp& value) const
3886  {
3887  typedef NullUInt64 Null;
3888 
3889  const BodySize offset = 0;
3890 
3891  return ordinary(value, offset, Null());
3892  }
3893 
3894  /// Bitmap field of eight Boolean type indicators reflecting
3895  /// the end of updates for a given event.
3896  const MatchEventIndicator&
3898  {
3899  const BodySize offset = 8;
3900 
3901  return ordinary<MatchEventIndicator>(offset);
3902  }
3903 
3904  /// Total number of messages contained within batch which is
3905  /// defined by match event indicator (5799).
3907  {
3908  const BodySize offset = 9;
3909 
3910  return ordinary<UInt16>(offset);
3911  }
3912 
3913  /// Indicates date of trade referenced in this message in
3914  /// YYYYMMDD format (expressed in local time at place of
3915  /// trade). Returned only in trade and trade cancel execution
3916  /// reports.
3917  bool tradeDate(Timestamp& value) const
3918  {
3919  typedef NullLocalMktDate Null;
3920  typedef LocalMktDate FieldValue;
3921 
3922  const BodySize offset = 11;
3923 
3924  FieldValue fieldValue;
3925 
3926  if (ordinary(fieldValue, offset, Null()))
3927  {
3928  value = localMktDateToTimestamp(fieldValue);
3929  return true;
3930  }
3931  return false;
3932  }
3933 
3934  /// Returns instance of Entries repeating group.
3936  {
3937  return
3938  groups().
3939  head<Entries>();
3940  }
3941 
3942  /// Size of message body in bytes.
3945  {
3946  return 13;
3947  }
3948 
3949  /// Returns class name.
3951  static const Char* className()
3952  {
3953  return "IncrementalRefreshTradeBlocks349";
3954  }
3955 
3956  /// FIX message type.
3958  static StrRef fixType()
3959  {
3960  return toStrRef("X");
3961  }
3962 };
3963 
3964 /// MDIncrementalRefreshEris.
3967 : BinaryMessage
3968 {
3969  /// Message template ID from SBE schema.
3970  enum { TemplateId = 351 };
3971 
3972  /// Number of entries in Market Data message..
3973  /// Entry of Entry repeating group.
3976  <
3978  >
3979  {
3980  /// Aliases base class type.
3981  typedef
3983  <
3985  >
3987 
3988  /// Initializes blank instance.
3990  {
3991  }
3992 
3993  /// Initializes instance of given
3994  /// version over given memory block.
3996  const void* data,
3997  BodySize size,
3998  SchemaVersion version)
3999  : Base(data, size, version)
4000  {
4001  if (size < bodySize(version))
4002  throwBadBinaryData(className());
4003  }
4004 
4005  /// Number of entries in AltID group..
4006  /// Entry of SecurityAltIDEntry repeating group.
4009  <
4011  >
4012  {
4013  /// Aliases base class type.
4014  typedef
4016  <
4018  >
4020 
4021  /// Initializes blank instance.
4023  {
4024  }
4025 
4026  /// Initializes instance of given
4027  /// version over given memory block.
4029  const void* data,
4030  BodySize size,
4031  SchemaVersion version)
4032  : Base(data, size, version)
4033  {
4034  if (size < bodySize(version))
4035  throwBadBinaryData(className());
4036  }
4037 
4038  /// Expanded instrument description.
4039  bool securityAltId(StrRef& value) const
4040  {
4041  const BodySize offset = 0;
4042  const BodySize length = 26;
4043 
4044  return fixedStr<length>(value, offset);
4045  }
4046 
4047  /// Identifies class or source of the SecurityAltID (455)
4048  /// value.
4050  {
4051  const BodySize offset = 26;
4052  const BodySize length = 1;
4053 
4054  return fixedStr<length>(offset);
4055  }
4056 
4057  /// Returns size of entry body in bytes
4058  /// for given version of message template.
4061  {
4062  return 27;
4063  }
4064 
4065  /// Entity class name.
4067  static const Char* className()
4068  {
4069  return "Entries.SecurityAltIDEntry";
4070  }
4071  };
4072 
4073  /// Repeating group containing SecurityAltIDEntry entries.
4074  typedef
4077 
4078  /// Number of repeating EventType entries..
4079  /// Entry of EventsEntry repeating group.
4082  <
4084  >
4085  {
4086  /// Aliases base class type.
4087  typedef
4089  <
4091  >
4093 
4094  /// Initializes blank instance.
4096  {
4097  }
4098 
4099  /// Initializes instance of given
4100  /// version over given memory block.
4102  const void* data,
4103  BodySize size,
4104  SchemaVersion version)
4105  : Base(data, size, version)
4106  {
4107  if (size < bodySize(version))
4108  throwBadBinaryData(className());
4109  }
4110 
4111  /// Code to represent the type of event.
4113  {
4114  const BodySize offset = 0;
4115 
4116  return ordinary<UInt8>(offset);
4117  }
4118 
4119  /// Time of event. This is UTC Time.
4120  bool eventTime(UInt64& value) const
4121  {
4122  typedef NullUInt64 Null;
4123 
4124  const BodySize offset = 1;
4125 
4126  return ordinary(value, offset, Null());
4127  }
4128 
4129  /// Returns size of entry body in bytes
4130  /// for given version of message template.
4133  {
4134  return 9;
4135  }
4136 
4137  /// Entity class name.
4139  static const Char* className()
4140  {
4141  return "Entries.EventsEntry";
4142  }
4143  };
4144 
4145  /// Repeating group containing EventsEntry entries.
4146  typedef
4149 
4150  /// Indicates the type of Market Data update action.
4152  {
4153  const BodySize offset = 0;
4154 
4155  return ordinary<CHAR>(offset);
4156  }
4157 
4158  /// Indicates the type of Market Data entry.
4159  CHAR entryType() const
4160  {
4161  const BodySize offset = 1;
4162 
4163  return ordinary<CHAR>(offset);
4164  }
4165 
4166  /// MD Entry sequence number per instrument update. Reset
4167  /// weekly.
4168  UInt32 rptSeq() const
4169  {
4170  const BodySize offset = 2;
4171 
4172  return ordinary<UInt32>(offset);
4173  }
4174 
4175  /// Price of the Market Data Entry.
4177  {
4178  const BodySize offset = 6;
4179 
4180  return ordinary<Decimal64>(offset);
4181  }
4182 
4183  /// Quantity or volume represented by the Market Data Entry.
4184  bool entrySize(UInt64& value) const
4185  {
4186  typedef NullUInt64 Null;
4187 
4188  const BodySize offset = 15;
4189 
4190  return ordinary(value, offset, Null());
4191  }
4192 
4193  /// Calculated Futures Price using Swap NPV, Historical fixed
4194  /// and floating amounts and synthetic interest on variation
4195  /// margin.
4197  {
4198  const BodySize offset = 23;
4199 
4200  return ordinary<Decimal64>(offset);
4201  }
4202 
4203  /// Position in the book.
4204  bool entryPositionNo(Int32& value) const
4205  {
4206  typedef NullInt32 Null;
4207 
4208  const BodySize offset = 32;
4209 
4210  return ordinary(value, offset, Null());
4211  }
4212 
4213  /// Number of orders working at a price level. Not sent on
4214  /// implied.
4215  bool numberOfOrders(Int32& value) const
4216  {
4217  typedef NullInt32 Null;
4218 
4219  const BodySize offset = 36;
4220 
4221  return ordinary(value, offset, Null());
4222  }
4223 
4224  /// The unique identifier for the trade entry, per instrument
4225  /// + trading date.
4226  Int32 tradeId() const
4227  {
4228  const BodySize offset = 40;
4229 
4230  return ordinary<Int32>(offset);
4231  }
4232 
4233  /// Indicates which side is aggressor of the trade. If there
4234  /// is no value present, then there is no aggressor.
4235  bool
4237  AggressorSide::Enum& value) const
4238  {
4239  typedef NullUInt8 Null;
4240 
4241  const BodySize offset = 44;
4242 
4243  return enumeration<AggressorSide>(value, offset, Null());
4244  }
4245 
4246  /// Instrument/Index/Swap Name.
4247  bool symbol(StrRef& value) const
4248  {
4249  const BodySize offset = 45;
4250  const BodySize length = 50;
4251 
4252  return fixedStr<length>(value, offset);
4253  }
4254 
4255  /// Indicates the product code for the instrument.
4256  bool securityGroup(StrRef& value) const
4257  {
4258  const BodySize offset = 95;
4259  const BodySize length = 26;
4260 
4261  return fixedStr<length>(value, offset);
4262  }
4263 
4264  /// Identifies the type of instrument.
4265  bool securityType(StrRef& value) const
4266  {
4267  const BodySize offset = 121;
4268  const BodySize length = 9;
4269 
4270  return fixedStr<length>(value, offset);
4271  }
4272 
4273  /// Market used to help identify an instrument.
4275  {
4276  const BodySize offset = 130;
4277  const BodySize length = 4;
4278 
4279  return fixedStr<length>(offset);
4280  }
4281 
4282  /// Indicates the type of product the instrument is associated
4283  /// with in the message.
4284  bool product(UInt8& value) const
4285  {
4286  typedef NullUInt8 Null;
4287 
4288  const BodySize offset = 134;
4289 
4290  return ordinary(value, offset, Null());
4291  }
4292 
4293  /// Maturity date of instrument.
4294  bool maturityDate(Timestamp& value) const
4295  {
4296  typedef NullLocalMktDate Null;
4297  typedef LocalMktDate FieldValue;
4298 
4299  const BodySize offset = 135;
4300 
4301  FieldValue fieldValue;
4302 
4303  if (ordinary(fieldValue, offset, Null()))
4304  {
4305  value = localMktDateToTimestamp(fieldValue);
4306  return true;
4307  }
4308  return false;
4309  }
4310 
4311  /// For future use.
4312  bool referenceId(StrRef& value) const
4313  {
4314  const BodySize offset = 137;
4315  const BodySize length = 50;
4316 
4317  return fixedStr<length>(value, offset);
4318  }
4319 
4320  /// Returns instance of SecurityAltID repeating group.
4322  {
4323  return
4324  groups().
4325  head<SecurityAltID>();
4326  }
4327 
4328  /// Returns instance of Events repeating group.
4329  Events events() const
4330  {
4331  return
4332  groups().
4333  tail<SecurityAltID>().
4334  head<Events>();
4335  }
4336 
4337  /// Returns size of entry body in bytes
4338  /// for given version of message template.
4341  {
4342  return 187;
4343  }
4344 
4345  /// Returns reference to the next item.
4347  {
4348  const void* body = events().end().get().body();
4349  return Entry(
4350  body,
4351  bodySize(version()),
4352  version());
4353  }
4354 
4355  /// Entity class name.
4357  static const Char* className()
4358  {
4359  return "IncrementalRefreshEris351.Entry";
4360  }
4361  };
4362 
4363  /// Repeating group containing Entry entries.
4364  typedef
4367 
4368  /// Initializes blank instance.
4370  {
4371  }
4372 
4373  /// Initializes instance over given memory block.
4375  const void* data,
4376  MessageSize size)
4377  : BinaryMessage(data, size)
4378  {
4379  assert(TemplateId == templateId());
4380 
4381  if (size < bodySize(version()))
4382  throwBadBinaryData(className());
4383  }
4384 
4385  /// Start of event processing time in number of nanoseconds
4386  /// since Unix epoch.
4388  {
4389  const BodySize offset = 0;
4390 
4391  return ordinary<Timestamp>(offset);
4392  }
4393 
4394  /// Bitmap field of eight Boolean type indicators reflecting
4395  /// the end of updates for a given event.
4396  const MatchEventIndicator&
4398  {
4399  const BodySize offset = 8;
4400 
4401  return ordinary<MatchEventIndicator>(offset);
4402  }
4403 
4404  /// Total number of messages contained within batch which is
4405  /// defined by match event indicator (5799).
4406  bool batchTotalMessages(UInt16& value) const
4407  {
4408  typedef NullUInt16 Null;
4409 
4410  const BodySize offset = 9;
4411 
4412  return ordinary(value, offset, Null());
4413  }
4414 
4415  /// Returns instance of Entries repeating group.
4417  {
4418  return
4419  groups().
4420  head<Entries>();
4421  }
4422 
4423  /// Size of message body in bytes.
4426  {
4427  return 11;
4428  }
4429 
4430  /// Returns class name.
4432  static const Char* className()
4433  {
4434  return "IncrementalRefreshEris351";
4435  }
4436 
4437  /// FIX message type.
4439  static StrRef fixType()
4440  {
4441  return toStrRef("X");
4442  }
4443 };
4444 
4445 /// MDIncrementalRefreshEris.
4448 : BinaryMessage
4449 {
4450  /// Message template ID from SBE schema.
4451  enum { TemplateId = 353 };
4452 
4453  /// Number of entries in Market Data message..
4454  /// Entry of Entry repeating group.
4457  <
4459  >
4460  {
4461  /// Aliases base class type.
4462  typedef
4464  <
4466  >
4468 
4469  /// Initializes blank instance.
4471  {
4472  }
4473 
4474  /// Initializes instance of given
4475  /// version over given memory block.
4477  const void* data,
4478  BodySize size,
4479  SchemaVersion version)
4480  : Base(data, size, version)
4481  {
4482  if (size < bodySize(version))
4483  throwBadBinaryData(className());
4484  }
4485 
4486  /// Number of entries in AltID group..
4487  /// Entry of SecurityAltIDEntry repeating group.
4490  <
4492  >
4493  {
4494  /// Aliases base class type.
4495  typedef
4497  <
4499  >
4501 
4502  /// Initializes blank instance.
4504  {
4505  }
4506 
4507  /// Initializes instance of given
4508  /// version over given memory block.
4510  const void* data,
4511  BodySize size,
4512  SchemaVersion version)
4513  : Base(data, size, version)
4514  {
4515  if (size < bodySize(version))
4516  throwBadBinaryData(className());
4517  }
4518 
4519  /// Expanded instrument description.
4520  bool securityAltId(StrRef& value) const
4521  {
4522  const BodySize offset = 0;
4523  const BodySize length = 26;
4524 
4525  return fixedStr<length>(value, offset);
4526  }
4527 
4528  /// Identifies class or source of the SecurityAltID (455)
4529  /// value.
4531  {
4532  const BodySize offset = 26;
4533  const BodySize length = 1;
4534 
4535  return fixedStr<length>(offset);
4536  }
4537 
4538  /// Returns size of entry body in bytes
4539  /// for given version of message template.
4542  {
4543  return 27;
4544  }
4545 
4546  /// Entity class name.
4548  static const Char* className()
4549  {
4550  return "Entries.SecurityAltIDEntry";
4551  }
4552  };
4553 
4554  /// Repeating group containing SecurityAltIDEntry entries.
4555  typedef
4558 
4559  /// Number of repeating EventType entries..
4560  /// Entry of EventsEntry repeating group.
4563  <
4565  >
4566  {
4567  /// Aliases base class type.
4568  typedef
4570  <
4572  >
4574 
4575  /// Initializes blank instance.
4577  {
4578  }
4579 
4580  /// Initializes instance of given
4581  /// version over given memory block.
4583  const void* data,
4584  BodySize size,
4585  SchemaVersion version)
4586  : Base(data, size, version)
4587  {
4588  if (size < bodySize(version))
4589  throwBadBinaryData(className());
4590  }
4591 
4592  /// Code to represent the type of event.
4594  {
4595  const BodySize offset = 0;
4596 
4597  return ordinary<UInt8>(offset);
4598  }
4599 
4600  /// Time of event. This is number of days since unix epoch.
4601  bool eventTime(UInt64& value) const
4602  {
4603  typedef NullUInt64 Null;
4604 
4605  const BodySize offset = 1;
4606 
4607  return ordinary(value, offset, Null());
4608  }
4609 
4610  /// Returns size of entry body in bytes
4611  /// for given version of message template.
4614  {
4615  return 9;
4616  }
4617 
4618  /// Entity class name.
4620  static const Char* className()
4621  {
4622  return "Entries.EventsEntry";
4623  }
4624  };
4625 
4626  /// Repeating group containing EventsEntry entries.
4627  typedef
4630 
4631  /// Indicates the type of Market Data update action.
4633  {
4634  const BodySize offset = 0;
4635 
4636  return ordinary<CHAR>(offset);
4637  }
4638 
4639  /// Indicates the type of Market Data entry.
4640  CHAR entryType() const
4641  {
4642  const BodySize offset = 1;
4643 
4644  return ordinary<CHAR>(offset);
4645  }
4646 
4647  /// MD Entry sequence number per instrument update. Reset
4648  /// weekly.
4649  UInt32 rptSeq() const
4650  {
4651  const BodySize offset = 2;
4652 
4653  return ordinary<UInt32>(offset);
4654  }
4655 
4656  /// Price of the Market Data Entry.
4658  {
4659  const BodySize offset = 6;
4660 
4661  return ordinary<Decimal64>(offset);
4662  }
4663 
4664  /// Quantity or volume represented by the Market Data Entry.
4665  bool entrySize(UInt64& value) const
4666  {
4667  typedef NullUInt64 Null;
4668 
4669  const BodySize offset = 15;
4670 
4671  return ordinary(value, offset, Null());
4672  }
4673 
4674  /// Calculated Futures Price using Swap NPV, Historical fixed
4675  /// and floating amounts and synthetic interest on variation
4676  /// margin.
4678  {
4679  const BodySize offset = 23;
4680 
4681  return ordinary<Decimal64>(offset);
4682  }
4683 
4684  /// Position in the book.
4685  bool entryPositionNo(Int32& value) const
4686  {
4687  typedef NullInt32 Null;
4688 
4689  const BodySize offset = 32;
4690 
4691  return ordinary(value, offset, Null());
4692  }
4693 
4694  /// Number of orders working at a price level. Not sent on
4695  /// implied.
4696  bool numberOfOrders(Int32& value) const
4697  {
4698  typedef NullInt32 Null;
4699 
4700  const BodySize offset = 36;
4701 
4702  return ordinary(value, offset, Null());
4703  }
4704 
4705  /// The unique identifier for the trade entry, per instrument
4706  /// + trading date.
4707  Int32 tradeId() const
4708  {
4709  const BodySize offset = 40;
4710 
4711  return ordinary<Int32>(offset);
4712  }
4713 
4714  /// Indicates which side is aggressor of the trade. If there
4715  /// is no value present, then there is no aggressor.
4716  bool
4718  AggressorSide::Enum& value) const
4719  {
4720  typedef NullUInt8 Null;
4721 
4722  const BodySize offset = 44;
4723 
4724  return enumeration<AggressorSide>(value, offset, Null());
4725  }
4726 
4727  /// Instrument/Index/Swap Name.
4728  bool symbol(StrRef& value) const
4729  {
4730  const BodySize offset = 45;
4731  const BodySize length = 50;
4732 
4733  return fixedStr<length>(value, offset);
4734  }
4735 
4736  /// Indicates the product code for the instrument.
4737  bool securityGroup(StrRef& value) const
4738  {
4739  const BodySize offset = 95;
4740  const BodySize length = 26;
4741 
4742  return fixedStr<length>(value, offset);
4743  }
4744 
4745  /// Identifies the type of instrument.
4746  bool securityType(StrRef& value) const
4747  {
4748  const BodySize offset = 121;
4749  const BodySize length = 9;
4750 
4751  return fixedStr<length>(value, offset);
4752  }
4753 
4754  /// Market used to help identify an instrument.
4756  {
4757  const BodySize offset = 130;
4758  const BodySize length = 4;
4759 
4760  return fixedStr<length>(offset);
4761  }
4762 
4763  /// Indicates the type of product the instrument is associated
4764  /// with in the message.
4765  bool product(UInt8& value) const
4766  {
4767  typedef NullUInt8 Null;
4768 
4769  const BodySize offset = 134;
4770 
4771  return ordinary(value, offset, Null());
4772  }
4773 
4774  /// Maturity date of instrument.
4775  bool maturityDate(Timestamp& value) const
4776  {
4777  typedef NullLocalMktDate Null;
4778  typedef LocalMktDate FieldValue;
4779 
4780  const BodySize offset = 135;
4781 
4782  FieldValue fieldValue;
4783 
4784  if (ordinary(fieldValue, offset, Null()))
4785  {
4786  value = localMktDateToTimestamp(fieldValue);
4787  return true;
4788  }
4789  return false;
4790  }
4791 
4792  /// For future use.
4793  bool referenceId(StrRef& value) const
4794  {
4795  const BodySize offset = 137;
4796  const BodySize length = 50;
4797 
4798  return fixedStr<length>(value, offset);
4799  }
4800 
4801  /// Identifies the type of quote. 0=Indicative, 1=Tradeable.
4802  bool quoteType(UInt8& value) const
4803  {
4804  typedef NullUInt8 Null;
4805 
4806  const BodySize offset = 187;
4807 
4808  return ordinary(value, offset, Null());
4809  }
4810 
4811  /// Returns instance of SecurityAltID repeating group.
4813  {
4814  return
4815  groups().
4816  head<SecurityAltID>();
4817  }
4818 
4819  /// Returns instance of Events repeating group.
4820  Events events() const
4821  {
4822  return
4823  groups().
4824  tail<SecurityAltID>().
4825  head<Events>();
4826  }
4827 
4828  /// Returns size of entry body in bytes
4829  /// for given version of message template.
4832  {
4833  return 188;
4834  }
4835 
4836  /// Returns reference to the next item.
4838  {
4839  const void* body = events().end().get().body();
4840  return Entry(
4841  body,
4842  bodySize(version()),
4843  version());
4844  }
4845 
4846  /// Entity class name.
4848  static const Char* className()
4849  {
4850  return "IncrementalRefreshEris353.Entry";
4851  }
4852  };
4853 
4854  /// Repeating group containing Entry entries.
4855  typedef
4858 
4859  /// Initializes blank instance.
4861  {
4862  }
4863 
4864  /// Initializes instance over given memory block.
4866  const void* data,
4867  MessageSize size)
4868  : BinaryMessage(data, size)
4869  {
4870  assert(TemplateId == templateId());
4871 
4872  if (size < bodySize(version()))
4873  throwBadBinaryData(className());
4874  }
4875 
4876  /// Start of event processing time in number of nanoseconds
4877  /// since Unix epoch.
4879  {
4880  const BodySize offset = 0;
4881 
4882  return ordinary<Timestamp>(offset);
4883  }
4884 
4885  /// Bitmap field of eight Boolean type indicators reflecting
4886  /// the end of updates for a given event.
4887  const MatchEventIndicator&
4889  {
4890  const BodySize offset = 8;
4891 
4892  return ordinary<MatchEventIndicator>(offset);
4893  }
4894 
4895  /// Total number of messages contained within batch which is
4896  /// defined by match event indicator (5799).
4897  bool batchTotalMessages(UInt16& value) const
4898  {
4899  typedef NullUInt16 Null;
4900 
4901  const BodySize offset = 9;
4902 
4903  return ordinary(value, offset, Null());
4904  }
4905 
4906  /// Returns instance of Entries repeating group.
4908  {
4909  return
4910  groups().
4911  head<Entries>();
4912  }
4913 
4914  /// Size of message body in bytes.
4917  {
4918  return 11;
4919  }
4920 
4921  /// Returns class name.
4923  static const Char* className()
4924  {
4925  return "IncrementalRefreshEris353";
4926  }
4927 
4928  /// FIX message type.
4930  static StrRef fixType()
4931  {
4932  return toStrRef("X");
4933  }
4934 };
4935 
4936 /// MDIncrementalRefreshOTC.
4939 : BinaryMessage
4940 {
4941  /// Message template ID from SBE schema.
4942  enum { TemplateId = 356 };
4943 
4944  /// Number of entries in Market Data message..
4945  /// Entry of Entry repeating group.
4948  <
4950  >
4951  {
4952  /// Aliases base class type.
4953  typedef
4955  <
4957  >
4959 
4960  /// Initializes blank instance.
4962  {
4963  }
4964 
4965  /// Initializes instance of given
4966  /// version over given memory block.
4968  const void* data,
4969  BodySize size,
4970  SchemaVersion version)
4971  : Base(data, size, version)
4972  {
4973  if (size < bodySize(version))
4974  throwBadBinaryData(className());
4975  }
4976 
4977  /// Number of underlying legs that make up the security.
4978  /// Entry of UnderlyingsEntry repeating group.
4981  <
4983  >
4984  {
4985  /// Aliases base class type.
4986  typedef
4988  <
4990  >
4992 
4993  /// Initializes blank instance.
4995  {
4996  }
4997 
4998  /// Initializes instance of given
4999  /// version over given memory block.
5001  const void* data,
5002  BodySize size,
5003  SchemaVersion version)
5004  : Base(data, size, version)
5005  {
5006  if (size < bodySize(version))
5007  throwBadBinaryData(className());
5008  }
5009 
5010  /// Underlying Security's symbol.
5011  bool underlyingSymbol(StrRef& value) const
5012  {
5013  const BodySize offset = 0;
5014  const BodySize length = 50;
5015 
5016  return fixedStr<length>(value, offset);
5017  }
5018 
5019  /// Underlying Security's MaturityMonthYear.
5021  {
5022  typedef NullMaturityMonthYear Null;
5023 
5024  const BodySize offset = 50;
5025 
5026  return ordinary(value, offset, Null());
5027  }
5028 
5029  /// Underlying Security's SecurityType.
5030  bool underlyingSecurityType(StrRef& value) const
5031  {
5032  const BodySize offset = 55;
5033  const BodySize length = 9;
5034 
5035  return fixedStr<length>(value, offset);
5036  }
5037 
5038  /// Underlying Security's SecurityExchange and it can be used
5039  /// to identify the underlying security.
5041  {
5042  const BodySize offset = 64;
5043  const BodySize length = 4;
5044 
5045  return fixedStr<length>(offset);
5046  }
5047 
5048  /// Returns size of entry body in bytes
5049  /// for given version of message template.
5052  {
5053  return 68;
5054  }
5055 
5056  /// Entity class name.
5058  static const Char* className()
5059  {
5060  return "Entries.UnderlyingsEntry";
5061  }
5062  };
5063 
5064  /// Repeating group containing UnderlyingsEntry entries.
5065  typedef
5068 
5069  /// Number of entries in AltID group..
5070  /// Entry of SecurityAltIDEntry repeating group.
5073  <
5075  >
5076  {
5077  /// Aliases base class type.
5078  typedef
5080  <
5082  >
5084 
5085  /// Initializes blank instance.
5087  {
5088  }
5089 
5090  /// Initializes instance of given
5091  /// version over given memory block.
5093  const void* data,
5094  BodySize size,
5095  SchemaVersion version)
5096  : Base(data, size, version)
5097  {
5098  if (size < bodySize(version))
5099  throwBadBinaryData(className());
5100  }
5101 
5102  /// Expanded instrument description.
5103  bool securityAltId(StrRef& value) const
5104  {
5105  const BodySize offset = 0;
5106  const BodySize length = 50;
5107 
5108  return fixedStr<length>(value, offset);
5109  }
5110 
5111  /// Identifies class or source of the SecurityAltID (455)
5112  /// value.
5114  {
5115  const BodySize offset = 50;
5116  const BodySize length = 1;
5117 
5118  return fixedStr<length>(offset);
5119  }
5120 
5121  /// Returns size of entry body in bytes
5122  /// for given version of message template.
5125  {
5126  return 51;
5127  }
5128 
5129  /// Entity class name.
5131  static const Char* className()
5132  {
5133  return "Entries.SecurityAltIDEntry";
5134  }
5135  };
5136 
5137  /// Repeating group containing SecurityAltIDEntry entries.
5138  typedef
5141 
5142  /// Indicates the type of Market Data update action.
5144  {
5145  return UpdateActionNew();
5146  }
5147 
5148  /// Indicates the type of Market Data entry.
5149  CHAR entryType() const
5150  {
5151  const BodySize offset = 0;
5152 
5153  return ordinary<CHAR>(offset);
5154  }
5155 
5156  /// MD Entry sequence number per instrument update. Reset
5157  /// weekly.
5158  UInt32 rptSeq() const
5159  {
5160  const BodySize offset = 1;
5161 
5162  return ordinary<UInt32>(offset);
5163  }
5164 
5165  /// Price of the Market Data Entry.
5166  bool entryPx(PRICENULL& value) const
5167  {
5168  typedef NullPRICENULL Null;
5169 
5170  const BodySize offset = 5;
5171 
5172  return ordinary(value, offset, Null());
5173  }
5174 
5175  /// Quantity or volume represented by the Market Data Entry.
5177  {
5178  const BodySize offset = 13;
5179 
5180  return ordinary<Decimal64>(offset);
5181  }
5182 
5183  /// Instrument/Index/Swap Name.
5184  bool symbol(StrRef& value) const
5185  {
5186  const BodySize offset = 22;
5187  const BodySize length = 50;
5188 
5189  return fixedStr<length>(value, offset);
5190  }
5191 
5192  /// Indicates the product code for the instrument.
5193  bool securityGroup(StrRef& value) const
5194  {
5195  const BodySize offset = 72;
5196  const BodySize length = 12;
5197 
5198  return fixedStr<length>(value, offset);
5199  }
5200 
5201  /// Indicates the type of instrument.
5202  bool securityType(StrRef& value) const
5203  {
5204  const BodySize offset = 84;
5205  const BodySize length = 9;
5206 
5207  return fixedStr<length>(value, offset);
5208  }
5209 
5210  /// This field provides the actual calendar date for contract
5211  /// maturity month and year (used for standardized futures and
5212  /// options).
5214  {
5215  typedef NullMaturityMonthYear Null;
5216 
5217  const BodySize offset = 93;
5218 
5219  return ordinary(value, offset, Null());
5220  }
5221 
5222  /// Market used to help identify an instrument.
5224  {
5225  const BodySize offset = 98;
5226  const BodySize length = 4;
5227 
5228  return fixedStr<length>(offset);
5229  }
5230 
5231  /// Indicates the type of product the instrument is associated
5232  /// with in the message.
5233  bool product(UInt8& value) const
5234  {
5235  typedef NullUInt8 Null;
5236 
5237  const BodySize offset = 102;
5238 
5239  return ordinary(value, offset, Null());
5240  }
5241 
5242  /// Maturity date of instrument.
5243  bool maturityDate(Timestamp& value) const
5244  {
5245  typedef NullLocalMktDate Null;
5246  typedef LocalMktDate FieldValue;
5247 
5248  const BodySize offset = 103;
5249 
5250  FieldValue fieldValue;
5251 
5252  if (ordinary(fieldValue, offset, Null()))
5253  {
5254  value = localMktDateToTimestamp(fieldValue);
5255  return true;
5256  }
5257  return false;
5258  }
5259 
5260  /// The rate of interest that, when multiplied by the
5261  /// principal, par value, or face value of a bond, provides
5262  /// the currency amount of the periodic interest payment.
5263  bool couponRate(Decimal32& value) const
5264  {
5265  typedef NullDecimal32 Null;
5266 
5267  const BodySize offset = 105;
5268 
5269  return ordinary(value, offset, Null());
5270  }
5271 
5272  /// A category of CDS credit event in which the underlying
5273  /// bond experiences a restructuring.
5274  bool restructuringType(StrRef& value) const
5275  {
5276  const BodySize offset = 109;
5277  const BodySize length = 2;
5278 
5279  return fixedStr<length>(value, offset);
5280  }
5281 
5282  /// Specifies which issue (underlying bond) will receive
5283  /// payment priority in the event of a default.