OnixS C++ CME MDP Conflated UDP Handler  1.0.2
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 /// AdminLogin.
35 {
36  /// Message template ID from SBE schema.
37  enum { TemplateId = 408 };
38 
39  /// Initializes blank instance.
41  {
42  }
43 
44  /// Initializes instance over given memory block.
46  const void* data,
47  EncodedLength length)
48  : BinaryMessage(data, length)
49  {
50  assert(TemplateId == templateId());
51 
52  if (length < blockLength(version()))
53  throwBadBinaryData(className());
54  }
55 
56  /// Heartbeat interval (seconds).
57  Int8 heartBtInt() const
58  {
59  const BlockLength offset = 0;
60 
61  return ordinary<Int8>(offset);
62  }
63 
64  /// Size of message body in bytes.
67  {
68  return 1;
69  }
70 
71  /// Returns class name.
73  static const Char* className()
74  {
75  return "AdminLogin408";
76  }
77 
78  /// FIX message type.
80  static StrRef fixType()
81  {
82  return toStrRef("A");
83  }
84 };
85 
86 /// AdminLogout.
90 {
91  /// Message template ID from SBE schema.
92  enum { TemplateId = 409 };
93 
94  /// Initializes blank instance.
96  {
97  }
98 
99  /// Initializes instance over given memory block.
101  const void* data,
102  EncodedLength length)
103  : BinaryMessage(data, length)
104  {
105  assert(TemplateId == templateId());
106 
107  if (length < blockLength(version()))
108  throwBadBinaryData(className());
109  }
110 
111  /// Free format text string. May include logout confirmation
112  /// or reason for logout.
113  StrRef text() const
114  {
115  const BlockLength offset = 0;
116  const BlockLength length = 180;
117 
118  return fixedStr<length>(offset);
119  }
120 
121  /// Size of message body in bytes.
124  {
125  return 180;
126  }
127 
128  /// Returns class name.
130  static const Char* className()
131  {
132  return "AdminLogout409";
133  }
134 
135  /// FIX message type.
137  static StrRef fixType()
138  {
139  return toStrRef("5");
140  }
141 };
142 
143 /// AdminHeartbeat.
147 {
148  /// Message template ID from SBE schema.
149  enum { TemplateId = 410 };
150 
151  /// Initializes blank instance.
153  {
154  }
155 
156  /// Initializes instance over given memory block.
158  const void* data,
159  EncodedLength length)
160  : BinaryMessage(data, length)
161  {
162  assert(TemplateId == templateId());
163 
164  if (length < blockLength(version()))
165  throwBadBinaryData(className());
166  }
167 
168  /// Size of message body in bytes.
171  {
172  return 0;
173  }
174 
175  /// Returns class name.
177  static const Char* className()
178  {
179  return "AdminHeartbeat410";
180  }
181 
182  /// FIX message type.
184  static StrRef fixType()
185  {
186  return toStrRef("0");
187  }
188 };
189 
190 /// MDInstrumentDefinitionFX.
194 {
195  /// Message template ID from SBE schema.
196  enum { TemplateId = 63 };
197 
198  /// Number of EventType entries.
199  /// Entry of EventsEntry 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  EncodedLength length,
224  SchemaVersion version)
225  : Base(data, length, version)
226  {
227  if (length < blockLength(version))
228  throwBadBinaryData(className());
229  }
230 
231  /// Code to represent the type of event.
233  {
234  const BlockLength offset = 0;
235 
236  return enumeration<EventType>(offset);
237  }
238 
239  /// Date and Time of instument Activation or Expiration event
240  /// sent as number of nanoseconds since Unix epoch.
242  {
243  const BlockLength offset = 1;
244 
245  return ordinary<Timestamp>(offset);
246  }
247 
248  /// Returns size of entry body in bytes
249  /// for given version of message template.
252  {
253  return 9;
254  }
255 
256  /// Entity class name.
258  static const Char* className()
259  {
260  return "InstrumentDefinitionFX63.EventsEntry";
261  }
262  };
263 
264  /// Repeating group containing EventsEntry entries.
265  typedef
268 
269  /// Number of FeedType entries.
270  /// Entry of FeedTypesEntry repeating group.
273  <
275  >
276  {
277  /// Aliases base class type.
278  typedef
280  <
282  >
284 
285  /// Initializes blank instance.
287  {
288  }
289 
290  /// Initializes instance of given
291  /// version over given memory block.
293  const void* data,
294  EncodedLength length,
295  SchemaVersion version)
296  : Base(data, length, version)
297  {
298  if (length < blockLength(version))
299  throwBadBinaryData(className());
300  }
301 
302  /// Describes a class of service for a given data feed.
303  StrRef feedType() const
304  {
305  const BlockLength offset = 0;
306  const BlockLength length = 3;
307 
308  return fixedStr<length>(offset);
309  }
310 
311  /// Book depth.
313  {
314  const BlockLength offset = 3;
315 
316  return ordinary<Int8>(offset);
317  }
318 
319  /// Returns size of entry body in bytes
320  /// for given version of message template.
323  {
324  return 4;
325  }
326 
327  /// Entity class name.
329  static const Char* className()
330  {
331  return "InstrumentDefinitionFX63.FeedTypesEntry";
332  }
333  };
334 
335  /// Repeating group containing FeedTypesEntry entries.
336  typedef
339 
340  /// Number of InstrAttribType entries.
341  /// Entry of InstAttribEntry repeating group.
344  <
346  >
347  {
348  /// Aliases base class type.
349  typedef
351  <
353  >
355 
356  /// Initializes blank instance.
358  {
359  }
360 
361  /// Initializes instance of given
362  /// version over given memory block.
364  const void* data,
365  EncodedLength length,
366  SchemaVersion version)
367  : Base(data, length, version)
368  {
369  if (length < blockLength(version))
370  throwBadBinaryData(className());
371  }
372 
373  /// Instrument eligibility attributes.
375  {
376  return InstAttribType();
377  }
378 
379  /// Bitmap field of 32 Boolean type instrument eligibility
380  /// flags.
382  {
383  const BlockLength offset = 0;
384 
385  return ordinary<InstAttribValue>(offset);
386  }
387 
388  /// Returns size of entry body in bytes
389  /// for given version of message template.
392  {
393  return 4;
394  }
395 
396  /// Entity class name.
398  static const Char* className()
399  {
400  return "InstrumentDefinitionFX63.InstAttribEntry";
401  }
402  };
403 
404  /// Repeating group containing InstAttribEntry entries.
405  typedef
408 
409  /// Number of LotTypeRules entries.
410  /// Entry of LotTypeRulesEntry repeating group.
413  <
415  >
416  {
417  /// Aliases base class type.
418  typedef
420  <
422  >
424 
425  /// Initializes blank instance.
427  {
428  }
429 
430  /// Initializes instance of given
431  /// version over given memory block.
433  const void* data,
434  EncodedLength length,
435  SchemaVersion version)
436  : Base(data, length, version)
437  {
438  if (length < blockLength(version))
439  throwBadBinaryData(className());
440  }
441 
442  /// This tag is required to interpret the value in tag
443  /// 1231-MinLotSize.
444  Int8 lotType() const
445  {
446  const BlockLength offset = 0;
447 
448  return ordinary<Int8>(offset);
449  }
450 
451  /// For FX instruments in the repeating group with Tag
452  /// 1093-LotType=2, Tag 1231-MinLotSize provides a Regular
453  /// Amount - a default order size on the Workstation screen.
454  /// With tag 1093-LotType= 5, Tag 1231-MinLotSize value
455  /// represents standard min order qty increment.
457  {
458  const BlockLength offset = 1;
459 
460  return ordinary<UInt64>(offset);
461  }
462 
463  /// Returns size of entry body in bytes
464  /// for given version of message template.
467  {
468  return 9;
469  }
470 
471  /// Entity class name.
473  static const Char* className()
474  {
475  return "InstrumentDefinitionFX63.LotTypeRulesEntry";
476  }
477  };
478 
479  /// Repeating group containing LotTypeRulesEntry entries.
480  typedef
483 
484  /// Number of scheduled Trading Dates.
485  /// Entry of TradingSessionsEntry repeating group.
488  <
490  >
491  {
492  /// Aliases base class type.
493  typedef
495  <
497  >
499 
500  /// Initializes blank instance.
502  {
503  }
504 
505  /// Initializes instance of given
506  /// version over given memory block.
508  const void* data,
509  EncodedLength length,
510  SchemaVersion version)
511  : Base(data, length, version)
512  {
513  if (length < blockLength(version))
514  throwBadBinaryData(className());
515  }
516 
517  /// Trade Date.
518  bool tradeDate(Timestamp& value) const
519  {
520  typedef NullLocalMktDate Null;
521  typedef LocalMktDate FieldValue;
522 
523  const BlockLength offset = 0;
524 
525  FieldValue fieldValue;
526 
527  if (ordinary(fieldValue, offset, Null()))
528  {
529  value = localMktDateToTimestamp(fieldValue);
530  return true;
531  }
532  return false;
533  }
534 
535  /// Settle (Value) Date corresponding to Trade Date.
536  bool settlDate(Timestamp& value) const
537  {
538  typedef NullLocalMktDate Null;
539  typedef LocalMktDate FieldValue;
540 
541  const BlockLength offset = 2;
542 
543  FieldValue fieldValue;
544 
545  if (ordinary(fieldValue, offset, Null()))
546  {
547  value = localMktDateToTimestamp(fieldValue);
548  return true;
549  }
550  return false;
551  }
552 
553  /// For Spot instruments will not contain the value. For NDFs,
554  /// the valuation (fixing) date of the NDF. For Fixed Date
555  /// NDFs Value Date and Maturity Date remain constant for all
556  /// Trade Dates.
558  {
559  typedef NullLocalMktDate Null;
560  typedef LocalMktDate FieldValue;
561 
562  const BlockLength offset = 4;
563 
564  FieldValue fieldValue;
565 
566  if (ordinary(fieldValue, offset, Null()))
567  {
568  value = localMktDateToTimestamp(fieldValue);
569  return true;
570  }
571  return false;
572  }
573 
574  /// ISIN value as provided by ANNA, Association of National
575  /// Numbering Agencies. This field is populated for MTF-
576  /// Regulated NDFs and is unique for each Settle Date.
578  {
579  const BlockLength offset = 6;
580  const BlockLength length = 12;
581 
582  return fixedStr<length>(offset);
583  }
584 
585  /// Identifies class or source of the SecurityAltID (455)
586  /// value.
588  {
589  return SecurityAltIDSourceISIN();
590  }
591 
592  /// Returns size of entry body in bytes
593  /// for given version of message template.
596  {
597  if (version >= 10)
598  return 18;
599 
600  return 6;
601  }
602 
603  /// Entity class name.
605  static const Char* className()
606  {
607  return "InstrumentDefinitionFX63.TradingSessionsEntry";
608  }
609  };
610 
611  /// Repeating group containing TradingSessionsEntry entries.
612  typedef
615 
616  /// Initializes blank instance.
618  {
619  }
620 
621  /// Initializes instance over given memory block.
623  const void* data,
624  EncodedLength length)
625  : BinaryMessage(data, length)
626  {
627  assert(TemplateId == templateId());
628 
629  if (length < blockLength(version()))
630  throwBadBinaryData(className());
631  }
632 
633  /// Bitmap field of eight Boolean type indicators reflecting
634  /// the end of updates for a given Globex event.
636  {
637  const BlockLength offset = 0;
638 
639  return ordinary<MatchEventIndicator>(offset);
640  }
641 
642  /// Total number of instruments in the Replay loop. Used on
643  /// Replay Feed only.
645  {
646  typedef NullUInt32 Null;
647 
648  const BlockLength offset = 1;
649 
650  return ordinary(value, offset, Null());
651  }
652 
653  /// Last Security update action on Incremental feed, 'D' or
654  /// 'M' is used when a mid-week deletion or modification (i.e.
655  /// extension) occurs.
658  {
659  const BlockLength offset = 5;
660 
661  return enumeration<SecurityUpdateAction>(offset);
662  }
663 
664  /// Timestamp of when the instrument was last added, modified
665  /// or deleted.
667  {
668  const BlockLength offset = 6;
669 
670  return ordinary<Timestamp>(offset);
671  }
672 
673  /// Identifies the current state of the instrument. In
674  /// Security Definition message this tag is available in the
675  /// Instrument Replay feed only.
676  bool
679  {
680  typedef NullUInt8 Null;
681 
682  const BlockLength offset = 14;
683 
684  return enumeration<SecurityTradingStatus>(value, offset, Null());
685  }
686 
687  /// The channel ID as defined in the XML Configuration file.
688  Int16 applId() const
689  {
690  const BlockLength offset = 15;
691 
692  return ordinary<Int16>(offset);
693  }
694 
695  /// Identifies the market segment, populated for all CME
696  /// Globex instruments.
698  {
699  const BlockLength offset = 17;
700 
701  return ordinary<UInt8>(offset);
702  }
703 
704  /// Product complex.
706  {
707  const BlockLength offset = 18;
708 
709  return ordinary<UInt8>(offset);
710  }
711 
712  /// Exchange used to identify a security.
714  {
715  const BlockLength offset = 19;
716  const BlockLength length = 4;
717 
718  return fixedStr<length>(offset);
719  }
720 
721  /// Security Group Code.
723  {
724  const BlockLength offset = 23;
725  const BlockLength length = 6;
726 
727  return fixedStr<length>(offset);
728  }
729 
730  /// The underlying asset code also known as Product Code.
731  StrRef asset() const
732  {
733  const BlockLength offset = 29;
734  const BlockLength length = 6;
735 
736  return fixedStr<length>(offset);
737  }
738 
739  /// Instrument Name or Symbol.
740  StrRef symbol() const
741  {
742  const BlockLength offset = 35;
743  const BlockLength length = 20;
744 
745  return fixedStr<length>(offset);
746  }
747 
748  /// Unique instrument ID.
750  {
751  const BlockLength offset = 55;
752 
753  return ordinary<Int32>(offset);
754  }
755 
756  /// Identifies class or source of tag 48-SecurityID value.
758  {
759  return SecurityIDSource();
760  }
761 
762  /// Security Type.
764  {
765  const BlockLength offset = 59;
766  const BlockLength length = 6;
767 
768  return fixedStr<length>(offset);
769  }
770 
771  /// ISO standard instrument categorization code.
772  StrRef cfiCode() const
773  {
774  const BlockLength offset = 65;
775  const BlockLength length = 6;
776 
777  return fixedStr<length>(offset);
778  }
779 
780  /// Base currency.
781  StrRef currency() const
782  {
783  const BlockLength offset = 71;
784  const BlockLength length = 3;
785 
786  return fixedStr<length>(offset);
787  }
788 
789  /// Currency used for settlement, which may be different from
790  /// Local currency specified in Tag 1524 PriceQuoteCurrency.
792  {
793  const BlockLength offset = 74;
794  const BlockLength length = 3;
795 
796  return fixedStr<length>(offset);
797  }
798 
799  /// Local (counter) currency.
801  {
802  const BlockLength offset = 77;
803  const BlockLength length = 3;
804 
805  return fixedStr<length>(offset);
806  }
807 
808  /// Matching algorithm.
810  {
811  const BlockLength offset = 80;
812 
813  return ordinary<CHAR>(offset);
814  }
815 
816  /// The minimum trading volume for a security.
818  {
819  const BlockLength offset = 81;
820 
821  return ordinary<UInt32>(offset);
822  }
823 
824  /// The maximum trading volume for a security.
826  {
827  const BlockLength offset = 85;
828 
829  return ordinary<UInt32>(offset);
830  }
831 
832  /// Minimum price tick.
834  {
835  const BlockLength offset = 89;
836 
837  return decimal<PRICE9>(offset);
838  }
839 
840  /// Contains the multiplier to convert the CME Globex display
841  /// price to the conventional price.
843  {
844  const BlockLength offset = 97;
845 
846  return decimal<Decimal9>(offset);
847  }
848 
849  /// Specifies price decimal precision for EBS instrument.
851  {
852  const BlockLength offset = 105;
853 
854  return ordinary<UInt8>(offset);
855  }
856 
857  /// Unit of measure for the products' original contract size.
858  /// This will be populated for all products listed on CME
859  /// Globex.
861  {
862  const BlockLength offset = 106;
863  const BlockLength length = 30;
864 
865  return fixedStr<length>(offset);
866  }
867 
868  /// This field contains the contract size for each instrument.
869  /// Used in combination with tag 996-UnitofMeasure.
871  {
872  typedef NullDecimal9 Null;
873 
874  const BlockLength offset = 136;
875 
876  return decimal(value, offset, Null());
877  }
878 
879  /// Allowable high limit price for the trading day.
881  {
882  typedef NullPRICE9 Null;
883 
884  const BlockLength offset = 144;
885 
886  return decimal(value, offset, Null());
887  }
888 
889  /// Allowable low limit price for the trading day.
891  {
892  typedef NullPRICE9 Null;
893 
894  const BlockLength offset = 152;
895 
896  return decimal(value, offset, Null());
897  }
898 
899  /// Differential value for price banding.
901  {
902  typedef NullPRICE9 Null;
903 
904  const BlockLength offset = 160;
905 
906  return decimal(value, offset, Null());
907  }
908 
909  /// User-defined instruments flag.
911  {
912  const BlockLength offset = 168;
913 
914  return ordinary<UserDefinedInstrument>(offset);
915  }
916 
917  /// EBS instrument long name.
919  {
920  const BlockLength offset = 169;
921  const BlockLength length = 35;
922 
923  return fixedStr<length>(offset);
924  }
925 
926  /// Base/Local. Denotes the currency pair in CCY1/CCY2
927  /// convention.
929  {
930  const BlockLength offset = 204;
931  const BlockLength length = 7;
932 
933  return fixedStr<length>(offset);
934  }
935 
936  /// For SPOTs will contain 0. For Fixed date NDFs will contain
937  /// the value 'B'. For the standard NDFs tenors expressed
938  /// using Dx, Mx, Wx, and Yx values, where 'x' does not denote
939  /// business days, but calendar days.
941  {
942  const BlockLength offset = 211;
943  const BlockLength length = 3;
944 
945  return fixedStr<length>(offset);
946  }
947 
948  /// For SPOT, number of business days between trade date and
949  /// value (settlement) date. For NDF, number of business days
950  /// between NDF valuation (fixing) and settlement.
952  {
953  const BlockLength offset = 214;
954 
955  return ordinary<UInt16>(offset);
956  }
957 
958  /// Fixing Rate Description.
960  {
961  const BlockLength offset = 216;
962  const BlockLength length = 20;
963 
964  return fixedStr<length>(offset);
965  }
966 
967  /// Fixing Rate Source.
969  {
970  const BlockLength offset = 236;
971  const BlockLength length = 12;
972 
973  return fixedStr<length>(offset);
974  }
975 
976  /// Fixing Rate Local Time, denoted in HH:MM:SS format.
978  {
979  const BlockLength offset = 248;
980  const BlockLength length = 8;
981 
982  return fixedStr<length>(offset);
983  }
984 
985  /// Fixing Rate Local Time Zone corresponding to Fixing Local
986  /// Time.
988  {
989  const BlockLength offset = 256;
990  const BlockLength length = 20;
991 
992  return fixedStr<length>(offset);
993  }
994 
995  /// Minimum Quote Life in number of microseconds.
997  {
998  const BlockLength offset = 276;
999 
1000  return ordinary<UInt32>(offset);
1001  }
1002 
1003  /// Max allowed discretionary offset from Limit order price.
1004  /// When the value in this field = 0, discretionary price
1005  /// cannot be submitted for the instrument.
1007  {
1008  const BlockLength offset = 280;
1009 
1010  return decimal<PRICE9>(offset);
1011  }
1012 
1013  /// External unique instrument ID.
1015  {
1016  typedef NullUInt64 Null;
1017 
1018  const BlockLength offset = 288;
1019 
1020  return ordinary(value, offset, Null());
1021  }
1022 
1023  /// Fixed Date NDF Maturity.
1025  {
1026  typedef NullMaturityMonthYear Null;
1027 
1028  const BlockLength offset = 296;
1029 
1030  return ordinary(value, offset, Null());
1031  }
1032 
1033  /// Settlement Locale. Optionally used to differentiate
1034  /// settlement location.
1036  {
1037  const BlockLength offset = 301;
1038  const BlockLength length = 8;
1039 
1040  return fixedStr<length>(offset);
1041  }
1042 
1043  /// Returns instance of Events repeating group.
1044  Events events() const
1045  {
1046  return
1047  groups().
1048  head<Events>();
1049  }
1050 
1051  /// Returns instance of FeedTypes repeating group.
1053  {
1054  return
1055  groups().
1056  tail<Events>().
1057  head<FeedTypes>();
1058  }
1059 
1060  /// Returns instance of InstAttrib repeating group.
1062  {
1063  return
1064  groups().
1065  tail<Events>().
1066  tail<FeedTypes>().
1067  head<InstAttrib>();
1068  }
1069 
1070  /// Returns instance of LotTypeRules repeating group.
1072  {
1073  return
1074  groups().
1075  tail<Events>().
1076  tail<FeedTypes>().
1077  tail<InstAttrib>().
1078  head<LotTypeRules>();
1079  }
1080 
1081  /// Returns instance of TradingSessions repeating group.
1083  {
1084  return
1085  groups().
1086  tail<Events>().
1087  tail<FeedTypes>().
1088  tail<InstAttrib>().
1089  tail<LotTypeRules>().
1090  head<TradingSessions>();
1091  }
1092 
1093  /// Size of message body in bytes.
1096  {
1097  if (version >= 12)
1098  return 309;
1099 
1100  if (version >= 10)
1101  return 204;
1102 
1103  return 169;
1104  }
1105 
1106  /// Returns class name.
1108  static const Char* className()
1109  {
1110  return "InstrumentDefinitionFX63";
1111  }
1112 
1113  /// FIX message type.
1115  static StrRef fixType()
1116  {
1117  return toStrRef("d");
1118  }
1119 };
1120 
1121 /// MDIncrementalRefreshBookLongQty.
1124 : BinaryMessage
1125 {
1126  /// Message template ID from SBE schema.
1127  enum { TemplateId = 64 };
1128 
1129  /// Number of entries in Market Data message..
1130  /// Entry of Entry repeating group.
1133  <
1135  >
1136  {
1137  /// Aliases base class type.
1138  typedef
1140  <
1142  >
1144 
1145  /// Initializes blank instance.
1147  {
1148  }
1149 
1150  /// Initializes instance of given
1151  /// version over given memory block.
1153  const void* data,
1154  EncodedLength length,
1155  SchemaVersion version)
1156  : Base(data, length, version)
1157  {
1158  if (length < blockLength(version))
1159  throwBadBinaryData(className());
1160  }
1161 
1162  /// Market Data entry price.
1163  bool entryPx(Decimal& value) const
1164  {
1165  typedef NullPRICE9 Null;
1166 
1167  const BlockLength offset = 0;
1168 
1169  return decimal(value, offset, Null());
1170  }
1171 
1172  /// Aggregate booked qty at price level, notional.
1173  bool entrySize(UInt64& value) const
1174  {
1175  typedef NullUInt64 Null;
1176 
1177  const BlockLength offset = 8;
1178 
1179  return ordinary(value, offset, Null());
1180  }
1181 
1182  /// SecurityID.
1184  {
1185  const BlockLength offset = 16;
1186 
1187  return ordinary<Int32>(offset);
1188  }
1189 
1190  /// Market Data entry sequence number per instrument update.
1191  UInt32 rptSeq() const
1192  {
1193  const BlockLength offset = 20;
1194 
1195  return ordinary<UInt32>(offset);
1196  }
1197 
1198  /// In Book entry - aggregate number of orders at given price
1199  /// level.
1201  {
1202  typedef NullInt32 Null;
1203 
1204  const BlockLength offset = 24;
1205 
1206  return ordinary(value, offset, Null());
1207  }
1208 
1209  /// Aggregate book level.
1211  {
1212  const BlockLength offset = 28;
1213 
1214  return ordinary<UInt8>(offset);
1215  }
1216 
1217  /// Market Data update action.
1219  {
1220  const BlockLength offset = 29;
1221 
1222  return enumeration<UpdateAction>(offset);
1223  }
1224 
1225  /// Market Data entry type.
1227  {
1228  const BlockLength offset = 30;
1229 
1230  return enumeration<EntryTypeBook>(offset);
1231  }
1232 
1233  /// Returns size of entry body in bytes
1234  /// for given version of message template.
1237  {
1238  return 31;
1239  }
1240 
1241  /// Entity class name.
1243  static const Char* className()
1244  {
1245  return "IncrementalRefreshBookLongQty64.Entry";
1246  }
1247  };
1248 
1249  /// Repeating group containing Entry entries.
1250  typedef
1253 
1254  /// Number of OrderID entries.
1255  /// Entry of OrderIDEntry repeating group.
1258  <
1260  >
1261  {
1262  /// Aliases base class type.
1263  typedef
1265  <
1267  >
1269 
1270  /// Initializes blank instance.
1272  {
1273  }
1274 
1275  /// Initializes instance of given
1276  /// version over given memory block.
1278  const void* data,
1279  EncodedLength length,
1280  SchemaVersion version)
1281  : Base(data, length, version)
1282  {
1283  if (length < blockLength(version))
1284  throwBadBinaryData(className());
1285  }
1286 
1287  /// Unique Order ID.
1288  UInt64 orderId() const
1289  {
1290  const BlockLength offset = 0;
1291 
1292  return ordinary<UInt64>(offset);
1293  }
1294 
1295  /// Order priority for execution on the order book.
1297  {
1298  typedef NullUInt64 Null;
1299 
1300  const BlockLength offset = 8;
1301 
1302  return ordinary(value, offset, Null());
1303  }
1304 
1305  /// Visible qty of order.
1306  bool displayQty(Int32& value) const
1307  {
1308  typedef NullInt32 Null;
1309 
1310  const BlockLength offset = 16;
1311 
1312  return ordinary(value, offset, Null());
1313  }
1314 
1315  /// Reference to corresponding Price and SecurityID, sequence
1316  /// of MD entry in the message.
1317  bool referenceId(UInt8& value) const
1318  {
1319  typedef NullUInt8 Null;
1320 
1321  const BlockLength offset = 20;
1322 
1323  return ordinary(value, offset, Null());
1324  }
1325 
1326  /// Order book update action to be applied to the order
1327  /// referenced by OrderID.
1329  {
1330  const BlockLength offset = 21;
1331 
1332  return enumeration<OrderUpdateAction>(offset);
1333  }
1334 
1335  /// Returns size of entry body in bytes
1336  /// for given version of message template.
1339  {
1340  return 22;
1341  }
1342 
1343  /// Entity class name.
1345  static const Char* className()
1346  {
1347  return "IncrementalRefreshBookLongQty64.OrderIDEntry";
1348  }
1349  };
1350 
1351  /// Repeating group containing OrderIDEntry entries.
1352  typedef
1355 
1356  /// Initializes blank instance.
1358  {
1359  }
1360 
1361  /// Initializes instance over given memory block.
1363  const void* data,
1364  EncodedLength length)
1365  : BinaryMessage(data, length)
1366  {
1367  assert(TemplateId == templateId());
1368 
1369  if (length < blockLength(version()))
1370  throwBadBinaryData(className());
1371  }
1372 
1373  /// Start of event processing time in number of nanoseconds
1374  /// since Unix epoch.
1376  {
1377  const BlockLength offset = 0;
1378 
1379  return ordinary<Timestamp>(offset);
1380  }
1381 
1382  /// Bitmap field of eight Boolean type indicators reflecting
1383  /// the end of updates for a given Globex event.
1385  {
1386  const BlockLength offset = 8;
1387 
1388  return ordinary<MatchEventIndicator>(offset);
1389  }
1390 
1391  /// Returns instance of Entries repeating group.
1393  {
1394  return
1395  groups().
1396  head<Entries>();
1397  }
1398 
1399  /// Returns instance of OrderIDEntries repeating group.
1401  {
1402  return
1403  groups().
1404  tail<Entries>().
1405  head<OrderIDEntries>();
1406  }
1407 
1408  /// Size of message body in bytes.
1411  {
1412  return 9;
1413  }
1414 
1415  /// Returns class name.
1417  static const Char* className()
1418  {
1419  return "IncrementalRefreshBookLongQty64";
1420  }
1421 
1422  /// FIX message type.
1424  static StrRef fixType()
1425  {
1426  return toStrRef("X");
1427  }
1428 };
1429 
1430 /// MDIncrementalRefreshTradeSummaryLongQty.
1433 : BinaryMessage
1434 {
1435  /// Message template ID from SBE schema.
1436  enum { TemplateId = 65 };
1437 
1438  /// Number of Trade Summary entries.
1439  /// Entry of Entry repeating group.
1442  <
1444  >
1445  {
1446  /// Aliases base class type.
1447  typedef
1449  <
1451  >
1453 
1454  /// Initializes blank instance.
1456  {
1457  }
1458 
1459  /// Initializes instance of given
1460  /// version over given memory block.
1462  const void* data,
1463  EncodedLength length,
1464  SchemaVersion version)
1465  : Base(data, length, version)
1466  {
1467  if (length < blockLength(version))
1468  throwBadBinaryData(className());
1469  }
1470 
1471  /// Trade price.
1473  {
1474  const BlockLength offset = 0;
1475 
1476  return decimal<PRICE9>(offset);
1477  }
1478 
1479  /// Consolidated trade quantity, notional.
1481  {
1482  const BlockLength offset = 8;
1483 
1484  return ordinary<UInt64>(offset);
1485  }
1486 
1487  /// Security ID.
1489  {
1490  const BlockLength offset = 16;
1491 
1492  return ordinary<Int32>(offset);
1493  }
1494 
1495  /// MD Entry sequence number per instrument update. Reset
1496  /// weekly.
1497  UInt32 rptSeq() const
1498  {
1499  const BlockLength offset = 20;
1500 
1501  return ordinary<UInt32>(offset);
1502  }
1503 
1504  /// The total number of real orders per instrument that
1505  /// participated in a match step within a match event.
1507  {
1508  const BlockLength offset = 24;
1509 
1510  return ordinary<Int32>(offset);
1511  }
1512 
1513  /// Market Data Trade Entry ID.
1515  {
1516  const BlockLength offset = 28;
1517 
1518  return ordinary<UInt32>(offset);
1519  }
1520 
1521  /// Indicates which side is the aggressor or if there is no
1522  /// aggressor.
1523  bool
1525  AggressorSide::Enum& value) const
1526  {
1527  typedef NullUInt8 Null;
1528 
1529  const BlockLength offset = 32;
1530 
1531  return enumeration<AggressorSide>(value, offset, Null());
1532  }
1533 
1534  /// Market Data update action.
1536  {
1537  const BlockLength offset = 33;
1538 
1539  return enumeration<UpdateAction>(offset);
1540  }
1541 
1542  /// Market Data entry type.
1544  {
1545  return EntryTypeTrade();
1546  }
1547 
1548  /// Returns size of entry body in bytes
1549  /// for given version of message template.
1552  {
1553  return 34;
1554  }
1555 
1556  /// Entity class name.
1558  static const Char* className()
1559  {
1560  return "IncrementalRefreshTradeSummaryLongQty65.Entry";
1561  }
1562  };
1563 
1564  /// Repeating group containing Entry entries.
1565  typedef
1568 
1569  /// Number of OrderID and LastQty entries in Trade Summary
1570  /// message.
1571  /// Entry of OrderIDEntry repeating group.
1574  <
1576  >
1577  {
1578  /// Aliases base class type.
1579  typedef
1581  <
1583  >
1585 
1586  /// Initializes blank instance.
1588  {
1589  }
1590 
1591  /// Initializes instance of given
1592  /// version over given memory block.
1594  const void* data,
1595  EncodedLength length,
1596  SchemaVersion version)
1597  : Base(data, length, version)
1598  {
1599  if (length < blockLength(version))
1600  throwBadBinaryData(className());
1601  }
1602 
1603  /// Unique order identifier as assigned by the exchange.
1604  UInt64 orderId() const
1605  {
1606  const BlockLength offset = 0;
1607 
1608  return ordinary<UInt64>(offset);
1609  }
1610 
1611  /// Quantity bought or sold on this last fill.
1612  Int32 lastQty() const
1613  {
1614  const BlockLength offset = 8;
1615 
1616  return ordinary<Int32>(offset);
1617  }
1618 
1619  /// Returns size of entry body in bytes
1620  /// for given version of message template.
1623  {
1624  return 12;
1625  }
1626 
1627  /// Entity class name.
1629  static const Char* className()
1630  {
1631  return "IncrementalRefreshTradeSummaryLongQty65.OrderIDEntry";
1632  }
1633  };
1634 
1635  /// Repeating group containing OrderIDEntry entries.
1636  typedef
1639 
1640  /// Initializes blank instance.
1642  {
1643  }
1644 
1645  /// Initializes instance over given memory block.
1647  const void* data,
1648  EncodedLength length)
1649  : BinaryMessage(data, length)
1650  {
1651  assert(TemplateId == templateId());
1652 
1653  if (length < blockLength(version()))
1654  throwBadBinaryData(className());
1655  }
1656 
1657  /// Start of event processing time in number of nanoseconds
1658  /// since Unix epoch.
1660  {
1661  const BlockLength offset = 0;
1662 
1663  return ordinary<Timestamp>(offset);
1664  }
1665 
1666  /// Bitmap field of eight Boolean type indicators reflecting
1667  /// the end of updates for a given Globex event.
1669  {
1670  const BlockLength offset = 8;
1671 
1672  return ordinary<MatchEventIndicator>(offset);
1673  }
1674 
1675  /// Returns instance of Entries repeating group.
1677  {
1678  return
1679  groups().
1680  head<Entries>();
1681  }
1682 
1683  /// Returns instance of OrderIDEntries repeating group.
1685  {
1686  return
1687  groups().
1688  tail<Entries>().
1689  head<OrderIDEntries>();
1690  }
1691 
1692  /// Size of message body in bytes.
1695  {
1696  return 9;
1697  }
1698 
1699  /// Returns class name.
1701  static const Char* className()
1702  {
1703  return "IncrementalRefreshTradeSummaryLongQty65";
1704  }
1705 
1706  /// FIX message type.
1708  static StrRef fixType()
1709  {
1710  return toStrRef("X");
1711  }
1712 };
1713 
1714 /// SnapshotFullRefreshLongQty.
1717 : BinaryMessage
1718 {
1719  /// Message template ID from SBE schema.
1720  enum { TemplateId = 69 };
1721 
1722  /// Number of entries in Market Data message.
1723  /// Entry of Entry repeating group.
1726  <
1728  >
1729  {
1730  /// Aliases base class type.
1731  typedef
1733  <
1735  >
1737 
1738  /// Initializes blank instance.
1740  {
1741  }
1742 
1743  /// Initializes instance of given
1744  /// version over given memory block.
1746  const void* data,
1747  EncodedLength length,
1748  SchemaVersion version)
1749  : Base(data, length, version)
1750  {
1751  if (length < blockLength(version))
1752  throwBadBinaryData(className());
1753  }
1754 
1755  /// Market Data entry price.
1756  bool entryPx(Decimal& value) const
1757  {
1758  typedef NullPRICE9 Null;
1759 
1760  const BlockLength offset = 0;
1761 
1762  return decimal(value, offset, Null());
1763  }
1764 
1765  /// Market Data entry size.
1766  bool entrySize(UInt64& value) const
1767  {
1768  typedef NullUInt64 Null;
1769 
1770  const BlockLength offset = 8;
1771 
1772  return ordinary(value, offset, Null());
1773  }
1774 
1775  /// In Book Entry - Aggregate number of orders at given price
1776  /// level. In Trade Entry - a total number of real orders per
1777  /// instrument that participated in a match step within a
1778  /// match event.
1780  {
1781  typedef NullInt32 Null;
1782 
1783  const BlockLength offset = 16;
1784 
1785  return ordinary(value, offset, Null());
1786  }
1787 
1788  /// Aggregate book level.
1789  bool priceLevel(UInt8& value) const
1790  {
1791  typedef NullUInt8 Null;
1792 
1793  const BlockLength offset = 20;
1794 
1795  return ordinary(value, offset, Null());
1796  }
1797 
1798  /// Flag that additionally describes a market data entry.
1799  bool
1802  {
1803  typedef NullUInt8 Null;
1804 
1805  const BlockLength offset = 21;
1806 
1807  return enumeration<OpenCloseSettlFlag>(value, offset, Null());
1808  }
1809 
1810  /// Market Data entry type.
1812  {
1813  const BlockLength offset = 22;
1814 
1815  return enumeration<EntryType>(offset);
1816  }
1817 
1818  /// Returns size of entry body in bytes
1819  /// for given version of message template.
1822  {
1823  return 23;
1824  }
1825 
1826  /// Entity class name.
1828  static const Char* className()
1829  {
1830  return "SnapshotFullRefreshLongQty69.Entry";
1831  }
1832  };
1833 
1834  /// Repeating group containing Entry entries.
1835  typedef
1838 
1839  /// Initializes blank instance.
1841  {
1842  }
1843 
1844  /// Initializes instance over given memory block.
1846  const void* data,
1847  EncodedLength length)
1848  : BinaryMessage(data, length)
1849  {
1850  assert(TemplateId == templateId());
1851 
1852  if (length < blockLength(version()))
1853  throwBadBinaryData(className());
1854  }
1855 
1856  /// Sequence number of the last Incremental feed packet
1857  /// processed. This value is used to synchronize the snapshot
1858  /// loop with the real-time feed.
1860  {
1861  const BlockLength offset = 0;
1862 
1863  return ordinary<UInt32>(offset);
1864  }
1865 
1866  /// Total number of instruments in the Replay loop. Used on
1867  /// Replay Feed only.
1869  {
1870  const BlockLength offset = 4;
1871 
1872  return ordinary<UInt32>(offset);
1873  }
1874 
1875  /// Unique instrument ID.
1877  {
1878  const BlockLength offset = 8;
1879 
1880  return ordinary<Int32>(offset);
1881  }
1882 
1883  /// MD Entry sequence number per instrument update. Reset
1884  /// weekly.
1885  UInt32 rptSeq() const
1886  {
1887  const BlockLength offset = 12;
1888 
1889  return ordinary<UInt32>(offset);
1890  }
1891 
1892  /// Timestamp of the last event security participated in, sent
1893  /// as number of nanoseconds since Unix epoch.
1895  {
1896  const BlockLength offset = 16;
1897 
1898  return ordinary<Timestamp>(offset);
1899  }
1900 
1901  /// UTC Date and time of last Security Definition add, update
1902  /// or delete on a given Market Data channel.
1904  {
1905  const BlockLength offset = 24;
1906 
1907  return ordinary<Timestamp>(offset);
1908  }
1909 
1910  /// Trade session date sent as number of days since Unix epoch.
1912  {
1913  typedef NullLocalMktDate Null;
1914  typedef LocalMktDate FieldValue;
1915 
1916  const BlockLength offset = 32;
1917 
1918  FieldValue fieldValue;
1919 
1920  if (ordinary(fieldValue, offset, Null()))
1921  {
1922  value = localMktDateToTimestamp(fieldValue);
1923  return true;
1924  }
1925  return false;
1926  }
1927 
1928  /// Identifies the current trading state of the instrument.
1929  bool
1932  {
1933  typedef NullUInt8 Null;
1934 
1935  const BlockLength offset = 34;
1936 
1937  return enumeration<SecurityTradingStatus>(value, offset, Null());
1938  }
1939 
1940  /// Upper price threshold for the instrument. Orders submitted
1941  /// with prices above the upper limit will be rejected.
1943  {
1944  typedef NullPRICE9 Null;
1945 
1946  const BlockLength offset = 35;
1947 
1948  return decimal(value, offset, Null());
1949  }
1950 
1951  /// Lower price threshold for the instrument. Orders submitted
1952  /// with prices below the lower limit will be rejected.
1954  {
1955  typedef NullPRICE9 Null;
1956 
1957  const BlockLength offset = 43;
1958 
1959  return decimal(value, offset, Null());
1960  }
1961 
1962  /// Differential value for price banding.
1964  {
1965  typedef NullPRICE9 Null;
1966 
1967  const BlockLength offset = 51;
1968 
1969  return decimal(value, offset, Null());
1970  }
1971 
1972  /// Returns instance of Entries repeating group.
1974  {
1975  return
1976  groups().
1977  head<Entries>();
1978  }
1979 
1980  /// Size of message body in bytes.
1983  {
1984  return 59;
1985  }
1986 
1987  /// Returns class name.
1989  static const Char* className()
1990  {
1991  return "SnapshotFullRefreshLongQty69";
1992  }
1993 
1994  /// FIX message type.
1996  static StrRef fixType()
1997  {
1998  return toStrRef("W");
1999  }
2000 };
2001 
2002 /// ChannelReset.
2005 : BinaryMessage
2006 {
2007  /// Message template ID from SBE schema.
2008  enum { TemplateId = 4 };
2009 
2010  /// Number of entries in Market Data message.
2011  /// Entry of Entry repeating group.
2014  <
2016  >
2017  {
2018  /// Aliases base class type.
2019  typedef
2021  <
2023  >
2025 
2026  /// Initializes blank instance.
2028  {
2029  }
2030 
2031  /// Initializes instance of given
2032  /// version over given memory block.
2034  const void* data,
2035  EncodedLength length,
2036  SchemaVersion version)
2037  : Base(data, length, version)
2038  {
2039  if (length < blockLength(version))
2040  throwBadBinaryData(className());
2041  }
2042 
2043  /// Market Data update action.
2045  {
2046  return UpdateTypeNew();
2047  }
2048 
2049  /// Market Data entry type.
2051  {
2052  return EntryTypeChannelReset();
2053  }
2054 
2055  /// Indicates the channel ID as defined in the XML
2056  /// configuration file.
2057  Int16 applId() const
2058  {
2059  const BlockLength offset = 0;
2060 
2061  return ordinary<Int16>(offset);
2062  }
2063 
2064  /// Returns size of entry body in bytes
2065  /// for given version of message template.
2068  {
2069  return 2;
2070  }
2071 
2072  /// Entity class name.
2074  static const Char* className()
2075  {
2076  return "ChannelReset4.Entry";
2077  }
2078  };
2079 
2080  /// Repeating group containing Entry entries.
2081  typedef
2084 
2085  /// Initializes blank instance.
2087  {
2088  }
2089 
2090  /// Initializes instance over given memory block.
2092  const void* data,
2093  EncodedLength length)
2094  : BinaryMessage(data, length)
2095  {
2096  assert(TemplateId == templateId());
2097 
2098  if (length < blockLength(version()))
2099  throwBadBinaryData(className());
2100  }
2101 
2102  /// Start of event processing time in number of nanoseconds
2103  /// since Unix epoch.
2105  {
2106  const BlockLength offset = 0;
2107 
2108  return ordinary<Timestamp>(offset);
2109  }
2110 
2111  /// Bitmap field of eight Boolean type indicators reflecting
2112  /// the end of updates for a given Globex event.
2114  {
2115  const BlockLength offset = 8;
2116 
2117  return ordinary<MatchEventIndicator>(offset);
2118  }
2119 
2120  /// Returns instance of Entries repeating group.
2122  {
2123  return
2124  groups().
2125  head<Entries>();
2126  }
2127 
2128  /// Size of message body in bytes.
2131  {
2132  return 9;
2133  }
2134 
2135  /// Returns class name.
2137  static const Char* className()
2138  {
2139  return "ChannelReset4";
2140  }
2141 
2142  /// FIX message type.
2144  static StrRef fixType()
2145  {
2146  return toStrRef("X");
2147  }
2148 };
2149 
2150 /// AdminHeartbeat.
2153 : BinaryMessage
2154 {
2155  /// Message template ID from SBE schema.
2156  enum { TemplateId = 12 };
2157 
2158  /// Initializes blank instance.
2160  {
2161  }
2162 
2163  /// Initializes instance over given memory block.
2165  const void* data,
2166  EncodedLength length)
2167  : BinaryMessage(data, length)
2168  {
2169  assert(TemplateId == templateId());
2170 
2171  if (length < blockLength(version()))
2172  throwBadBinaryData(className());
2173  }
2174 
2175  /// Size of message body in bytes.
2178  {
2179  return 0;
2180  }
2181 
2182  /// Returns class name.
2184  static const Char* className()
2185  {
2186  return "AdminHeartbeat12";
2187  }
2188 
2189  /// FIX message type.
2191  static StrRef fixType()
2192  {
2193  return toStrRef("0");
2194  }
2195 };
2196 
2197 /// AdminLogin.
2199 AdminLogin15
2200 : BinaryMessage
2201 {
2202  /// Message template ID from SBE schema.
2203  enum { TemplateId = 15 };
2204 
2205  /// Initializes blank instance.
2207  {
2208  }
2209 
2210  /// Initializes instance over given memory block.
2212  const void* data,
2213  EncodedLength length)
2214  : BinaryMessage(data, length)
2215  {
2216  assert(TemplateId == templateId());
2217 
2218  if (length < blockLength(version()))
2219  throwBadBinaryData(className());
2220  }
2221 
2222  /// Heartbeat interval (seconds).
2224  {
2225  const BlockLength offset = 0;
2226 
2227  return ordinary<Int8>(offset);
2228  }
2229 
2230  /// Size of message body in bytes.
2233  {
2234  return 1;
2235  }
2236 
2237  /// Returns class name.
2239  static const Char* className()
2240  {
2241  return "AdminLogin15";
2242  }
2243 
2244  /// FIX message type.
2246  static StrRef fixType()
2247  {
2248  return toStrRef("A");
2249  }
2250 };
2251 
2252 /// AdminLogout.
2255 : BinaryMessage
2256 {
2257  /// Message template ID from SBE schema.
2258  enum { TemplateId = 16 };
2259 
2260  /// Initializes blank instance.
2262  {
2263  }
2264 
2265  /// Initializes instance over given memory block.
2267  const void* data,
2268  EncodedLength length)
2269  : BinaryMessage(data, length)
2270  {
2271  assert(TemplateId == templateId());
2272 
2273  if (length < blockLength(version()))
2274  throwBadBinaryData(className());
2275  }
2276 
2277  /// Free format text string. May include logout confirmation
2278  /// or reason for logout.
2279  StrRef text() const
2280  {
2281  const BlockLength offset = 0;
2282  const BlockLength length = 180;
2283 
2284  return fixedStr<length>(offset);
2285  }
2286 
2287  /// Size of message body in bytes.
2290  {
2291  return 180;
2292  }
2293 
2294  /// Returns class name.
2296  static const Char* className()
2297  {
2298  return "AdminLogout16";
2299  }
2300 
2301  /// FIX message type.
2303  static StrRef fixType()
2304  {
2305  return toStrRef("5");
2306  }
2307 };
2308 
2309 /// SecurityStatus.
2312 : BinaryMessage
2313 {
2314  /// Message template ID from SBE schema.
2315  enum { TemplateId = 30 };
2316 
2317  /// Initializes blank instance.
2319  {
2320  }
2321 
2322  /// Initializes instance over given memory block.
2324  const void* data,
2325  EncodedLength length)
2326  : BinaryMessage(data, length)
2327  {
2328  assert(TemplateId == templateId());
2329 
2330  if (length < blockLength(version()))
2331  throwBadBinaryData(className());
2332  }
2333 
2334  /// Start of event processing time in number of nanoseconds
2335  /// since Unix epoch.
2337  {
2338  const BlockLength offset = 0;
2339 
2340  return ordinary<Timestamp>(offset);
2341  }
2342 
2343  /// Security Group.
2345  {
2346  const BlockLength offset = 8;
2347  const BlockLength length = 6;
2348 
2349  return fixedStr<length>(offset);
2350  }
2351 
2352  /// Product Code within Security Group specified.
2353  StrRef asset() const
2354  {
2355  const BlockLength offset = 14;
2356  const BlockLength length = 6;
2357 
2358  return fixedStr<length>(offset);
2359  }
2360 
2361  /// If this tag is present, 35=f message is sent for the
2362  /// instrument.
2363  bool securityId(Int32& value) const
2364  {
2365  typedef NullInt32 Null;
2366 
2367  const BlockLength offset = 20;
2368 
2369  return ordinary(value, offset, Null());
2370  }
2371 
2372  /// Trade Session Date.
2374  {
2375  typedef NullLocalMktDate Null;
2376  typedef LocalMktDate FieldValue;
2377 
2378  const BlockLength offset = 24;
2379 
2380  FieldValue fieldValue;
2381 
2382  if (ordinary(fieldValue, offset, Null()))
2383  {
2384  value = localMktDateToTimestamp(fieldValue);
2385  return true;
2386  }
2387  return false;
2388  }
2389 
2390  /// Bitmap field of eight Boolean type indicators reflecting
2391  /// the end of updates for a given Globex event.
2393  {
2394  const BlockLength offset = 26;
2395 
2396  return ordinary<MatchEventIndicator>(offset);
2397  }
2398 
2399  /// Identifies the trading status applicable to the instrument
2400  /// or Security Group.
2401  bool
2404  {
2405  typedef NullUInt8 Null;
2406 
2407  const BlockLength offset = 27;
2408 
2409  return enumeration<SecurityTradingStatus>(value, offset, Null());
2410  }
2411 
2412  /// Identifies the reason for the status change.
2414  {
2415  const BlockLength offset = 28;
2416 
2417  return enumeration<HaltReason>(offset);
2418  }
2419 
2420  /// Identifies an additional event or a rule related to the
2421  /// status.
2424  {
2425  const BlockLength offset = 29;
2426 
2427  return enumeration<SecurityTradingEvent>(offset);
2428  }
2429 
2430  /// Size of message body in bytes.
2433  {
2434  return 30;
2435  }
2436 
2437  /// Returns class name.
2439  static const Char* className()
2440  {
2441  return "SecurityStatus30";
2442  }
2443 
2444  /// FIX message type.
2446  static StrRef fixType()
2447  {
2448  return toStrRef("f");
2449  }
2450 };
2451 
2452 /// MDIncrementalRefreshLimitsBanding.
2455 : BinaryMessage
2456 {
2457  /// Message template ID from SBE schema.
2458  enum { TemplateId = 50 };
2459 
2460  /// Number of entries in Market Data message.
2461  /// Entry of Entry repeating group.
2464  <
2466  >
2467  {
2468  /// Aliases base class type.
2469  typedef
2471  <
2473  >
2475 
2476  /// Initializes blank instance.
2478  {
2479  }
2480 
2481  /// Initializes instance of given
2482  /// version over given memory block.
2484  const void* data,
2485  EncodedLength length,
2486  SchemaVersion version)
2487  : Base(data, length, version)
2488  {
2489  if (length < blockLength(version))
2490  throwBadBinaryData(className());
2491  }
2492 
2493  /// Upper price threshold for the instrument.
2495  {
2496  typedef NullPRICE9 Null;
2497 
2498  const BlockLength offset = 0;
2499 
2500  return decimal(value, offset, Null());
2501  }
2502 
2503  /// Lower price threshold for the instrument.
2505  {
2506  typedef NullPRICE9 Null;
2507 
2508  const BlockLength offset = 8;
2509 
2510  return decimal(value, offset, Null());
2511  }
2512 
2513  /// Differential static value for price banding.
2515  {
2516  typedef NullPRICE9 Null;
2517 
2518  const BlockLength offset = 16;
2519 
2520  return decimal(value, offset, Null());
2521  }
2522 
2523  /// Security ID.
2525  {
2526  const BlockLength offset = 24;
2527 
2528  return ordinary<Int32>(offset);
2529  }
2530 
2531  /// MD Entry sequence number per instrument update.
2532  UInt32 rptSeq() const
2533  {
2534  const BlockLength offset = 28;
2535 
2536  return ordinary<UInt32>(offset);
2537  }
2538 
2539  /// Market Data entry update action. In order to delete
2540  /// banding value, high or low limit, the deleted price field
2541  /// is populated with a NULL.
2543  {
2544  return UpdateActionNew();
2545  }
2546 
2547  /// Market Data entry type.
2549  {
2550  return EntryTypeLimits();
2551  }
2552 
2553  /// Returns size of entry body in bytes
2554  /// for given version of message template.
2557  {
2558  return 32;
2559  }
2560 
2561  /// Entity class name.
2563  static const Char* className()
2564  {
2565  return "IncrementalRefreshLimitsBanding50.Entry";
2566  }
2567  };
2568 
2569  /// Repeating group containing Entry entries.
2570  typedef
2573 
2574  /// Initializes blank instance.
2576  {
2577  }
2578 
2579  /// Initializes instance over given memory block.
2581  const void* data,
2582  EncodedLength length)
2583  : BinaryMessage(data, length)
2584  {
2585  assert(TemplateId == templateId());
2586 
2587  if (length < blockLength(version()))
2588  throwBadBinaryData(className());
2589  }
2590 
2591  /// Start of event processing time in number of nanoseconds
2592  /// since Unix epoch.
2594  {
2595  const BlockLength offset = 0;
2596 
2597  return ordinary<Timestamp>(offset);
2598  }
2599 
2600  /// Bitmap field of eight Boolean type indicators reflecting
2601  /// the end of updates for a given Globex event.
2603  {
2604  const BlockLength offset = 8;
2605 
2606  return ordinary<MatchEventIndicator>(offset);
2607  }
2608 
2609  /// Returns instance of Entries repeating group.
2611  {
2612  return
2613  groups().
2614  head<Entries>();
2615  }
2616 
2617  /// Size of message body in bytes.
2620  {
2621  return 9;
2622  }
2623 
2624  /// Returns class name.
2626  static const Char* className()
2627  {
2628  return "IncrementalRefreshLimitsBanding50";
2629  }
2630 
2631  /// FIX message type.
2633  static StrRef fixType()
2634  {
2635  return toStrRef("X");
2636  }
2637 };
2638 
2639 
bool displayQty(Int32 &value) const
Visible qty of order.
Definition: Messages.h:1306
IncrementalRefreshLimitsBanding50(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2580
bool maturityMonthYear(MaturityMonthYear &value) const
Fixed Date NDF Maturity.
Definition: Messages.h:1024
AdminHeartbeat410()
Initializes blank instance.
Definition: Messages.h:152
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1143
BinaryGroup< FeedTypesEntry, GroupSize, MessageSize > FeedTypes
Repeating group containing FeedTypesEntry entries.
Definition: Messages.h:338
A real number with floating exponent.
Definition: Decimal.h:231
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:1622
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:1676
UInt64 UInt64
uInt64.
Definition: Fields.h:265
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:329
MatchEventIndicator matchEventIndicator() const
Definition: Messages.h:2113
Entry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:2483
Null values definition for optional MaturityMonthYear field.
Definition: Composites.h:213
SecurityIDSource securityIdSource() const
Identifies class or source of tag 48-SecurityID value.
Definition: Messages.h:757
UInt32 rptSeq() const
Market Data entry sequence number per instrument update.
Definition: Messages.h:1191
StrRef fxBenchmarkRateFix() const
Fixing Rate Description.
Definition: Messages.h:959
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1694
Int8 heartBtInt() const
Heartbeat interval (seconds).
Definition: Messages.h:2223
UInt64 entrySize() const
Consolidated trade quantity, notional.
Definition: Messages.h:1480
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:1535
StrRef priceQuoteCurrency() const
Local (counter) currency.
Definition: Messages.h:800
IncrementalRefreshBookLongQty64()
Initializes blank instance.
Definition: Messages.h:1357
MessageHeader::Version SchemaVersion
Aliases SBE-encoded data version type.
Definition: SchemaTraits.h:30
CHAR matchAlgorithm() const
Matching algorithm.
Definition: Messages.h:809
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:1708
bool securityId(Int32 &value) const
Definition: Messages.h:2363
bool tradeDate(Timestamp &value) const
Trade session date sent as number of days since Unix epoch.
Definition: Messages.h:1911
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:1551
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2191
Int32 securityId() const
Unique instrument ID.
Definition: Messages.h:1876
IntegralConstant< Int8, 24 > InstAttribType
Eligibility.
Definition: Fields.h:61
bool highLimitPrice(Decimal &value) const
Allowable high limit price for the trading day.
Definition: Messages.h:880
StrRef currency() const
Base currency.
Definition: Messages.h:781
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2184
Int16 applId() const
The channel ID as defined in the XML Configuration file.
Definition: Messages.h:688
HaltReason::Enum haltReason() const
Identifies the reason for the status change.
Definition: Messages.h:2413
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Definition: Messages.h:2402
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2446
OrderIDEntries orderIdEntries() const
Returns instance of OrderIDEntries repeating group.
Definition: Messages.h:1400
FeedTypesEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:292
UInt8 pricePrecision() const
Specifies price decimal precision for EBS instrument.
Definition: Messages.h:850
Timestamp localMktDateToTimestamp(LocalMktDate days)
Converts days since epoch to Timestamp value.
Definition: Fields.h:1168
StrRef securityExchange() const
Exchange used to identify a security.
Definition: Messages.h:713
bool orderPriority(UInt64 &value) const
Order priority for execution on the order book.
Definition: Messages.h:1296
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1410
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:2610
Entry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:1152
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:258
Events events() const
Returns instance of Events repeating group.
Definition: Messages.h:1044
AdminLogout16(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2266
IntegralConstant< Char, '8'> SecurityIDSource
Definition: Fields.h:161
StrRef asset() const
Product Code within Security Group specified.
Definition: Messages.h:2353
bool instrumentGUId(UInt64 &value) const
External unique instrument ID.
Definition: Messages.h:1014
ChannelReset4()
Initializes blank instance.
Definition: Messages.h:2086
InstrumentDefinitionFX63(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:622
#define ONIXS_CONFLATEDUDP_LTWT_EXPORTED
Definition: Bootstrap.h:102
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2246
StrRef asset() const
The underlying asset code also known as Product Code.
Definition: Messages.h:731
bool tradeDate(Timestamp &value) const
Trade Session Date.
Definition: Messages.h:2373
Int32 Int32
int32.
Definition: Fields.h:69
bool entryPx(Decimal &value) const
Market Data entry price.
Definition: Messages.h:1163
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:1629
bool lowLimitPrice(Decimal &value) const
Allowable low limit price for the trading day.
Definition: Messages.h:890
SecurityStatus30()
Initializes blank instance.
Definition: Messages.h:2318
Represents time point without time-zone information.
Definition: Time.h:471
EntryTypeLimits entryType() const
Market Data entry type.
Definition: Messages.h:2548
AdminHeartbeat12(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2164
UInt8 underlyingProduct() const
Product complex.
Definition: Messages.h:705
IncrementalRefreshTradeSummaryLongQty65()
Initializes blank instance.
Definition: Messages.h:1641
Entry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:2033
AdminLogout409(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:100
Null values definition for optional Decimal9 field.
Definition: Composites.h:41
UpdateTypeNew updateAction() const
Market Data update action.
Definition: Messages.h:2044
Encapsulates operations over SBE-encoded repeating group.
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:1828
IntegralConstant< Char, '2'> EntryTypeTrade
MDEntryTypeTrade.
Definition: Fields.h:103
UserDefinedInstrument userDefinedInstrument() const
User-defined instruments flag.
Definition: Messages.h:910
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:2074
bool priceLevel(UInt8 &value) const
Aggregate book level.
Definition: Messages.h:1789
UInt32 UInt32
uInt32.
Definition: Fields.h:261
bool maxPriceVariation(Decimal &value) const
Differential static value for price banding.
Definition: Messages.h:2514
OrderIDEntries orderIdEntries() const
Returns instance of OrderIDEntries repeating group.
Definition: Messages.h:1684
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:177
LotTypeRulesEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:432
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:900
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:212
IncrementalRefreshBookLongQty64(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1362
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:1338
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:473
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:391
Null values definition for optional PRICE9 field.
Definition: Composites.h:250
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2619
Encapsulates services for manipulating SBE-encoded messages.
SecurityUpdateAction::Enum securityUpdateAction() const
Definition: Messages.h:657
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Identifies the current trading state of the instrument.
Definition: Messages.h:1930
Int32 lastQty() const
Quantity bought or sold on this last fill.
Definition: Messages.h:1612
char Char
Character type alias.
Definition: String.h:36
AdminLogin15(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2211
UInt32 rptSeq() const
MD Entry sequence number per instrument update.
Definition: Messages.h:2532
UInt32 minTradeVol() const
The minimum trading volume for a security.
Definition: Messages.h:817
Decimal minPriceIncrement() const
Minimum price tick.
Definition: Messages.h:833
bool lowLimitPrice(Decimal &value) const
Lower price threshold for the instrument.
Definition: Messages.h:2504
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:398
EventsEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:221
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2626
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:1996
bool entrySize(UInt64 &value) const
Aggregate booked qty at price level, notional.
Definition: Messages.h:1173
AdminLogin408()
Initializes blank instance.
Definition: Messages.h:40
bool maxPriceVariation(Decimal &value) const
Differential value for price banding.
Definition: Messages.h:1963
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:1837
BinaryGroup< InstAttribEntry, GroupSize, MessageSize > InstAttrib
Repeating group containing InstAttribEntry entries.
Definition: Messages.h:407
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:605
BinaryGroup< EventsEntry, GroupSize, MessageSize > Events
Repeating group containing EventsEntry entries.
Definition: Messages.h:267
Entry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:1461
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:1982
IntegralConstant< Char, 'J'> EntryTypeChannelReset
Channel Reset message entry type.
Definition: Fields.h:91
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:1973
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:1115
LotTypeRules lotTypeRules() const
Returns instance of LotTypeRules repeating group.
Definition: Messages.h:1071
bool highLimitPrice(Decimal &value) const
Upper price threshold for the instrument.
Definition: Messages.h:2494
IncrementalRefreshTradeSummaryLongQty65(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1646
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:498
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:322
#define ONIXS_CONFLATEDUDP_LTWT_STRUCT
Definition: Bootstrap.h:98
AdminLogin15()
Initializes blank instance.
Definition: Messages.h:2206
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:1417
Int16 Int16
int16.
Definition: Fields.h:65
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:1567
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:137
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2439
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:354
SnapshotFullRefreshLongQty69()
Initializes blank instance.
Definition: Messages.h:1840
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2130
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:251
EntryTypeBook::Enum entryType() const
Market Data entry type.
Definition: Messages.h:1226
AdminLogout16()
Initializes blank instance.
Definition: Messages.h:2261
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:73
bool entryPx(Decimal &value) const
Market Data entry price.
Definition: Messages.h:1756
SecurityTradingEvent::Enum securityTradingEvent() const
Definition: Messages.h:2423
BinaryGroup< OrderIDEntry, GroupSize8Byte, MessageSize > OrderIDEntries
Repeating group containing OrderIDEntry entries.
Definition: Messages.h:1638
StrRef rateSource() const
Fixing Rate Source.
Definition: Messages.h:968
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:1989
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2144
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:130
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:466
StrRef securityType() const
Security Type.
Definition: Messages.h:763
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:170
StrRef feedType() const
Describes a class of service for a given data feed.
Definition: Messages.h:303
EntryTypeTrade entryType() const
Market Data entry type.
Definition: Messages.h:1543
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:2067
FeedTypes feedTypes() const
Returns instance of FeedTypes repeating group.
Definition: Messages.h:1052
SnapshotFullRefreshLongQty69(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:1845
Int8 heartBtInt() const
Heartbeat interval (seconds).
Definition: Messages.h:57
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2303
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:1558
IntegralConstant< Char, 'g'> EntryTypeLimits
MDEntryTypeLimits.
Definition: Fields.h:97
AdminHeartbeat12()
Initializes blank instance.
Definition: Messages.h:2159
EntryType::Enum entryType() const
Market Data entry type.
Definition: Messages.h:1811
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:1236
MessageSize EncodedLength
Length of message binary data.
MatchEventIndicator type.
Definition: Fields.h:992
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:1108
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2024
IntegralConstant< Int8, 0 > UpdateActionNew
MDUpdateActionNew.
Definition: Fields.h:121
OrderIDEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:1277
UInt16 BlockLength
blockLength type.
Definition: Composites.h:291
#define ONIXS_CONFLATEDUDP_NAMESPACE_END
Definition: Bootstrap.h:156
bool entrySize(UInt64 &value) const
Market Data entry size.
Definition: Messages.h:1766
Entry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:1745
UInt16 UInt16
uInt16.
Definition: Fields.h:257
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:1392
OrderIDEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:1593
StrRef securityGroup() const
Security Group Code.
Definition: Messages.h:722
StrRef cfiCode() const
ISO standard instrument categorization code.
Definition: Messages.h:772
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:1252
Entry()
Initializes blank instance.
Definition: Messages.h:2027
StrRef securityGroup() const
Security Group.
Definition: Messages.h:2344
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:1821
StrRef fixRateLocalTime() const
Fixing Rate Local Time, denoted in HH:MM:SS format.
Definition: Messages.h:977
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2432
UInt64 orderId() const
Unique order identifier as assigned by the exchange.
Definition: Messages.h:1604
UInt32 minQuoteLife() const
Minimum Quote Life in number of microseconds.
Definition: Messages.h:996
UInt32 tradeEntryId() const
Market Data Trade Entry ID.
Definition: Messages.h:1514
MatchEventIndicator matchEventIndicator() const
Definition: Messages.h:2392
BinaryGroupEntry< GroupSize8Byte::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1584
StrRef financialInstrumentFullName() const
EBS instrument long name.
Definition: Messages.h:918
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2137
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:2563
UInt8 UInt8
uInt8.
Definition: Fields.h:269
bool unitOfMeasureQty(Decimal &value) const
Definition: Messages.h:870
MatchEventIndicator matchEventIndicator() const
Definition: Messages.h:635
StrRef toStrRef(const std::string &str)
Constructs StrRef instance over std::string content.
Definition: String.h:174
BinaryGroupEntry< GroupSize8Byte::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1268
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:184
BinaryGroup< OrderIDEntry, GroupSize8Byte, MessageSize > OrderIDEntries
Repeating group containing OrderIDEntry entries.
Definition: Messages.h:1354
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2239
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion version)
Size of message body in bytes.
Definition: Messages.h:1095
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:2474
IntegralConstant< UInt8, 4 > SecurityAltIDSourceISIN
Definition: Fields.h:141
InstrumentDefinitionFX63()
Initializes blank instance.
Definition: Messages.h:617
bool value(Number &number, const MultiContainer &container, Tag tag)
InstAttribType instAttribType() const
Instrument eligibility attributes.
Definition: Messages.h:374
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2177
InstAttrib instAttrib() const
Returns instance of InstAttrib repeating group.
Definition: Messages.h:1061
TradingSessions tradingSessions() const
Returns instance of TradingSessions repeating group.
Definition: Messages.h:1082
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:123
EventType::Enum eventType() const
Code to represent the type of event.
Definition: Messages.h:232
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2289
AdminLogout409()
Initializes blank instance.
Definition: Messages.h:95
IncrementalRefreshLimitsBanding50()
Initializes blank instance.
Definition: Messages.h:2575
bool settlDate(Timestamp &value) const
Settle (Value) Date corresponding to Trade Date.
Definition: Messages.h:536
ChannelReset4(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2091
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const
Definition: Messages.h:677
TradingSessionsEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:507
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:2572
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1452
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion version)
Definition: Messages.h:595
Entries entries() const
Returns instance of Entries repeating group.
Definition: Messages.h:2121
BinaryGroup< TradingSessionsEntry, GroupSize, MessageSize > TradingSessions
Repeating group containing TradingSessionsEntry entries.
Definition: Messages.h:614
AdminHeartbeat410(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:157
Int32 securityId() const
Unique instrument ID.
Definition: Messages.h:749
UpdateAction::Enum updateAction() const
Market Data update action.
Definition: Messages.h:1218
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:2232
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:2296
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:1424
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:423
UInt32 maxTradeVol() const
The maximum trading volume for a security.
Definition: Messages.h:825
ONIXS_CONFLATEDUDP_EXPORTED void throwBadBinaryData(const Char *className)
Throws exception on bad repeating group entry.
StrRef symbol() const
Instrument Name or Symbol.
Definition: Messages.h:740
bool openCloseSettlFlag(OpenCloseSettlFlag::Enum &value) const
Flag that additionally describes a market data entry.
Definition: Messages.h:1800
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:283
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Returns class name.
Definition: Messages.h:1701
SecurityStatus30(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:2323
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:1345
BinaryGroupEntry< GroupSize::BlockLength > Base
Aliases base class type.
Definition: Messages.h:1736
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:80
#define ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN
Definition: Bootstrap.h:152
AdminLogin408(const void *data, EncodedLength length)
Initializes instance over given memory block.
Definition: Messages.h:45
BinaryGroup< Entry, GroupSize, MessageSize > Entries
Repeating group containing Entry entries.
Definition: Messages.h:2083
InstAttribEntry(const void *data, EncodedLength length, SchemaVersion version)
Definition: Messages.h:363
static ONIXS_CONFLATEDUDP_EXPORTED StrRef fixType()
FIX message type.
Definition: Messages.h:2633
static ONIXS_CONFLATEDUDP_EXPORTED const Char * className()
Entity class name.
Definition: Messages.h:1243
BinaryGroup< LotTypeRulesEntry, GroupSize, MessageSize > LotTypeRules
Repeating group containing LotTypeRulesEntry entries.
Definition: Messages.h:482
EntryTypeChannelReset entryType() const
Market Data entry type.
Definition: Messages.h:2050
IntegralConstant< Int8, 0 > UpdateTypeNew
MDUpdateTypeNew.
Definition: Fields.h:127
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Definition: Messages.h:2556
static ONIXS_CONFLATEDUDP_EXPORTED BlockLength blockLength(SchemaVersion)
Size of message body in bytes.
Definition: Messages.h:66