OnixS C++ Euronext Optiq MDG Handler  1.3.3
API documentation
Messages.h
Go to the documentation of this file.
1 // Copyright Onix Solutions Limited [OnixS]. All rights reserved.
2 //
3 // This software owned by Onix Solutions Limited [OnixS] and is
4 // protected by copyright law and international copyright treaties.
5 //
6 // Access to and use of the software is governed by the terms of the applicable
7 // OnixS Software Services Agreement (the Agreement) and Customer end user license
8 // agreements granting a non-assignable, non-transferable and non-exclusive license
9 // to use the software for it's own data processing purposes under the terms defined
10 // in the Agreement.
11 //
12 // Except as otherwise granted within the terms of the Agreement, copying or
13 // reproduction of any part of this source code or associated reference material
14 // to any other location for further reproduction or redistribution, and any
15 // amendments to this copyright notice, are expressly prohibited.
16 //
17 // Any reproduction or redistribution for sale or hiring of the Software not in
18 // accordance with the terms of the Agreement is a violation of copyright law.
19 //
20 
21 #pragma once
22 
23 #include <cassert>
24 #include <stdexcept>
25 
27 #include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Forwards.h>
30 
32 
33 /// Message identifiers and length of message root.
36 : SbeMessage
37 {
38  /// Used template schema.
40 
41  /// Message template ID from SBE schema.
42  enum { TemplateId = 1101 };
43 
44  /// Initializes a blank instance.
46 
47  /// Creates an instance over the given memory block.
49  const void* data,
50  EncodedLength length)
51  : SbeMessage(data, length)
52  {
53  checkCompatibility();
54  }
55 
56  /// Creates an instance over the given SBE message.
57  explicit
59  const SbeMessage& message)
60  : SbeMessage(message)
61  {
62  assert(message.valid());
63 
64  checkCompatibility();
65  }
66 
67  /// Provides access to mDSeqNum field.
69  bool seqNum(Uint64& value) const
71  {
73 
74  return ordinary(value, offset, NullUint64());
75  }
76 
77  /// Provides access to sessionTradingDay field.
79  bool sessionTradingDay(Uint16& value) const
81  {
83 
84  return ordinary(value, offset, NullUint16());
85  }
86 
87  /// Minimal size of message body in bytes.
90  static
95  {
96  return
97  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
98  10;
99  }
100 
101  /// Size of message body in bytes.
106  {
107  return
108  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
109  minimalBlockLength(version);
110  }
111 
112  /// Minimal variable fields size (when variable-length fields are empty).
116  static
120  {
121  return
122  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
123  0;
124  }
125 
126  /// \return class name.
130  static const Char* className()
131  {
132  return "StartOfDay";
133  }
134 
135  /// FIX message type.
139  static StrRef fixType()
141  {
142  return constructStrRef("StartOfDay");
143  }
144 
145  /// \return a human-readable presentation.
147  std::string toString() const;
148 
149 private:
150  void checkLength(
151  EncodedLength length, SchemaVersion version) const
152  {
153  const EncodedLength minimalRequiredLength =
154  minimalBlockLength(version) +
155  MessageHeader::Size +
156  getMinimalVariableFieldsSize(version);
157 
158  checkBinaryLength(
159  *this, length, minimalRequiredLength);
160  }
161 
162  void checkCompatibility() const
163  {
164  assert(TemplateId == templateId());
165 
166  checkSchema<Schema>(schemaId(), version());
167  checkLength(bufferSize(), version());
168  }
169 };
170 
171 /// Message identifiers and length of message root.
173 EndOfDay
174 : SbeMessage
175 {
176  /// Used template schema.
178 
179  /// Message template ID from SBE schema.
180  enum { TemplateId = 1102 };
181 
182  /// Initializes a blank instance.
184 
185  /// Creates an instance over the given memory block.
187  const void* data,
188  EncodedLength length)
189  : SbeMessage(data, length)
190  {
191  checkCompatibility();
192  }
193 
194  /// Creates an instance over the given SBE message.
195  explicit
197  const SbeMessage& message)
198  : SbeMessage(message)
199  {
200  assert(message.valid());
201 
202  checkCompatibility();
203  }
204 
205  /// Provides access to mDSeqNum field.
207  bool seqNum(Uint64& value) const
209  {
211 
212  return ordinary(value, offset, NullUint64());
213  }
214 
215  /// Provides access to sessionTradingDay field.
217  bool sessionTradingDay(Uint16& value) const
219  {
221 
222  return ordinary(value, offset, NullUint16());
223  }
224 
225  /// Minimal size of message body in bytes.
228  static
233  {
234  return
235  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
236  10;
237  }
238 
239  /// Size of message body in bytes.
244  {
245  return
246  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
247  minimalBlockLength(version);
248  }
249 
250  /// Minimal variable fields size (when variable-length fields are empty).
254  static
258  {
259  return
260  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
261  0;
262  }
263 
264  /// \return class name.
268  static const Char* className()
269  {
270  return "EndOfDay";
271  }
272 
273  /// FIX message type.
277  static StrRef fixType()
279  {
280  return constructStrRef("EndOfDay");
281  }
282 
283  /// \return a human-readable presentation.
285  std::string toString() const;
286 
287 private:
288  void checkLength(
289  EncodedLength length, SchemaVersion version) const
290  {
291  const EncodedLength minimalRequiredLength =
292  minimalBlockLength(version) +
293  MessageHeader::Size +
294  getMinimalVariableFieldsSize(version);
295 
296  checkBinaryLength(
297  *this, length, minimalRequiredLength);
298  }
299 
300  void checkCompatibility() const
301  {
302  assert(TemplateId == templateId());
303 
304  checkSchema<Schema>(schemaId(), version());
305  checkLength(bufferSize(), version());
306  }
307 };
308 
309 /// Message identifiers and length of message root.
312 : SbeMessage
313 {
314  /// Used template schema.
316 
317  /// Message template ID from SBE schema.
318  enum { TemplateId = 1103 };
319 
320  /// Initializes a blank instance.
322 
323  /// Creates an instance over the given memory block.
325  const void* data,
326  EncodedLength length)
327  : SbeMessage(data, length)
328  {
329  checkCompatibility();
330  }
331 
332  /// Creates an instance over the given SBE message.
333  explicit
335  const SbeMessage& message)
336  : SbeMessage(message)
337  {
338  assert(message.valid());
339 
340  checkCompatibility();
341  }
342 
343  /// Provides access to mDSeqNum field.
345  bool seqNum(Uint64& value) const
347  {
349 
350  return ordinary(value, offset, NullUint64());
351  }
352 
353  /// Provides access to eventTime field.
355  bool eventTime(Uint64& value) const
357  {
359 
360  return ordinary(value, offset, NullUint64());
361  }
362 
363  /// Minimal size of message body in bytes.
366  static
371  {
372  return
373  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
374  16;
375  }
376 
377  /// Size of message body in bytes.
382  {
383  return
384  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
385  minimalBlockLength(version);
386  }
387 
388  /// Minimal variable fields size (when variable-length fields are empty).
392  static
396  {
397  return
398  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
399  0;
400  }
401 
402  /// \return class name.
406  static const Char* className()
407  {
408  return "HealthStatus";
409  }
410 
411  /// FIX message type.
415  static StrRef fixType()
417  {
418  return constructStrRef("HealthStatus");
419  }
420 
421  /// \return a human-readable presentation.
423  std::string toString() const;
424 
425 private:
426  void checkLength(
427  EncodedLength length, SchemaVersion version) const
428  {
429  const EncodedLength minimalRequiredLength =
430  minimalBlockLength(version) +
431  MessageHeader::Size +
432  getMinimalVariableFieldsSize(version);
433 
434  checkBinaryLength(
435  *this, length, minimalRequiredLength);
436  }
437 
438  void checkCompatibility() const
439  {
440  assert(TemplateId == templateId());
441 
442  checkSchema<Schema>(schemaId(), version());
443  checkLength(bufferSize(), version());
444  }
445 };
446 
447 /// Message identifiers and length of message root.
450 : SbeMessage
451 {
452  /// Used template schema.
454 
455  /// Message template ID from SBE schema.
456  enum { TemplateId = 1106 };
457 
458  /// Initializes a blank instance.
460 
461  /// Creates an instance over the given memory block.
463  const void* data,
464  EncodedLength length)
465  : SbeMessage(data, length)
466  {
467  checkCompatibility();
468  }
469 
470  /// Creates an instance over the given SBE message.
471  explicit
473  const SbeMessage& message)
474  : SbeMessage(message)
475  {
476  assert(message.valid());
477 
478  checkCompatibility();
479  }
480 
481  /// Provides access to mDSeqNum field.
483  bool seqNum(Uint64& value) const
485  {
487 
488  return ordinary(value, offset, NullUint64());
489  }
490 
491  /// Provides access to technicalNotificationType field.
496  {
498 
499  return enumeration<TechnicalNotificationType>(offset);
500  }
501 
502  /// Provides access to rebroadcastIndicator field.
506  {
508 
509  return ordinary(value, offset, NullUnsignedChar());
510  }
511 
512  /// Provides access to retransmissionStartTime field.
514  bool retransmissionStartTime(Uint64& value) const
516  {
518 
519  return ordinary(value, offset, NullUint64());
520  }
521 
522  /// Provides access to retransmissionEndTime field.
524  bool retransmissionEndTime(Uint64& value) const
526  {
528 
529  return ordinary(value, offset, NullUint64());
530  }
531 
532  /// Provides access to symbolIndex field.
534  bool symbolIndex(Uint32& value) const
536  {
538 
539  return ordinary(value, offset, NullUint32());
540  }
541 
542  /// Minimal size of message body in bytes.
545  static
550  {
551  return
552  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
553  30;
554  }
555 
556  /// Size of message body in bytes.
561  {
562  return
563  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
564  minimalBlockLength(version);
565  }
566 
567  /// Minimal variable fields size (when variable-length fields are empty).
571  static
575  {
576  return
577  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
578  0;
579  }
580 
581  /// \return class name.
585  static const Char* className()
586  {
587  return "TechnicalNotification";
588  }
589 
590  /// FIX message type.
594  static StrRef fixType()
596  {
597  return constructStrRef("TechnicalNotification");
598  }
599 
600  /// \return a human-readable presentation.
602  std::string toString() const;
603 
604 private:
605  void checkLength(
606  EncodedLength length, SchemaVersion version) const
607  {
608  const EncodedLength minimalRequiredLength =
609  minimalBlockLength(version) +
610  MessageHeader::Size +
611  getMinimalVariableFieldsSize(version);
612 
613  checkBinaryLength(
614  *this, length, minimalRequiredLength);
615  }
616 
617  void checkCompatibility() const
618  {
619  assert(TemplateId == templateId());
620 
621  checkSchema<Schema>(schemaId(), version());
622  checkLength(bufferSize(), version());
623  }
624 };
625 
626 /// Message identifiers and length of message root.
629 : SbeMessage
630 {
631  /// Used template schema.
633 
634  /// Message template ID from SBE schema.
635  enum { TemplateId = 1001 };
636 
637  /// Repeating group dimensions.
638  /// Entry of UpdatesEntry repeating group.
641  <
643  >
644  {
645  /// Base class type.
646  typedef
648  <
650  >
652 
653  /// Initializes instance of given
654  /// version over given memory block.
656  const void* data,
657  EncodedLength length,
658  SchemaVersion version)
659  : Base(data, numericCast<Base::BlockLength>(length), version)
660  {
661  assert(version >= Schema::MinimalVersion);
662  assert(length >= minimalBlockLength(version));
663  }
664 
665  /// Provides access to updateType field.
668  updateType() const
670  {
672 
673  return enumeration<MarketDataUpdateType>(offset);
674  }
675 
676  /// Provides access to symbolIndex field.
678  bool symbolIndex(Uint32& value) const
680  {
682 
683  return ordinary(value, offset, NullUint32());
684  }
685 
686  /// Provides access to numberOfOrders field.
688  bool numberOfOrders(Uint16& value) const
690  {
692 
693  return ordinary(value, offset, NullUint16());
694  }
695 
696  /// Provides access to price field.
698  bool price(Int64& value) const
700  {
702 
703  return ordinary(value, offset, NullInt64());
704  }
705 
706  /// Provides access to quantity field.
708  bool quantity(Uint64& value) const
710  {
712 
713  return ordinary(value, offset, NullUint64());
714  }
715 
716  /// \return size of entry body in bytes
717  /// for given version of message template.
722  {
723  return
724  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
725  minimalBlockLength(version);
726  }
727 
728  /// \return minimal size of entry body in bytes
729  /// for given version of message template.
732  static
737  {
738  return
739  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
740  23;
741  }
742 
743  /// Entity class name.
747  static const Char* className()
748  {
749  return "MarketUpdate.UpdatesEntry";
750  }
751  };
752 
753  /// Repeating group containing UpdatesEntry entries.
754  typedef
757 
758  /// Initializes a blank instance.
760 
761  /// Creates an instance over the given memory block.
763  const void* data,
764  EncodedLength length)
765  : SbeMessage(data, length)
766  {
767  checkCompatibility();
768  }
769 
770  /// Creates an instance over the given SBE message.
771  explicit
773  const SbeMessage& message)
774  : SbeMessage(message)
775  {
776  assert(message.valid());
777 
778  checkCompatibility();
779  }
780 
781  /// Provides access to mDSeqNum field.
783  bool seqNum(Uint64& value) const
785  {
787 
788  return ordinary(value, offset, NullUint64());
789  }
790 
791  /// Provides access to rebroadcastIndicator field.
795  {
797 
798  return ordinary(value, offset, NullUnsignedChar());
799  }
800 
801  /// Provides access to eMM field.
803  Emm::Enum eMM() const
805  {
807 
808  return enumeration<Emm>(offset);
809  }
810 
811  /// Provides access to eventTime field.
813  bool eventTime(Uint64& value) const
815  {
817 
818  return ordinary(value, offset, NullUint64());
819  }
820 
821  /// \return instance of Updates repeating group.
823  Updates updates() const
825  {
826  return getGroup<Updates>(UpdatesAccess(), *this);
827  }
828 
829  /// Minimal size of message body in bytes.
832  static
837  {
838  return
839  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
840  18;
841  }
842 
843  /// Size of message body in bytes.
848  {
849  return
850  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
851  minimalBlockLength(version);
852  }
853 
854  /// Minimal variable fields size (when variable-length fields are empty).
858  static
862  {
863  return
864  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
865  static_cast<MessageSize>(Updates::EmptySize);
866  }
867 
868  /// \return class name.
872  static const Char* className()
873  {
874  return "MarketUpdate";
875  }
876 
877  /// FIX message type.
881  static StrRef fixType()
883  {
884  return constructStrRef("MarketUpdate");
885  }
886 
887  /// \return a human-readable presentation.
889  std::string toString() const;
890 
891 private:
892  void checkLength(
893  EncodedLength length, SchemaVersion version) const
894  {
895  const EncodedLength minimalRequiredLength =
896  minimalBlockLength(version) +
897  MessageHeader::Size +
898  getMinimalVariableFieldsSize(version);
899 
900  checkBinaryLength(
901  *this, length, minimalRequiredLength);
902  }
903 
904  /// Checks variable fields consistency.
905  void checkVarLenFields() const
906  {
907  groups().
908  checkTail<Updates>();
909  }
910 
911  void checkCompatibility() const
912  {
913  assert(TemplateId == templateId());
914 
915  checkSchema<Schema>(schemaId(), version());
916  checkLength(bufferSize(), version());
917  checkVarLenFields();
918  }
919 
920  /// Access helper.
921  struct UpdatesAccess
922  {
923  Updates operator()(const MarketUpdate& obj) const
925  {
926  return obj.
927  groups().
928  head<Updates>();
929  }
930  };
931 };
932 
933 /// Message identifiers and length of message root.
936 : SbeMessage
937 {
938  /// Used template schema.
940 
941  /// Message template ID from SBE schema.
942  enum { TemplateId = 1002 };
943 
944  /// Repeating group dimensions.
945  /// Entry of OrdersEntry repeating group.
948  <
950  >
951  {
952  /// Base class type.
953  typedef
955  <
957  >
959 
960  /// Initializes instance of given
961  /// version over given memory block.
963  const void* data,
964  EncodedLength length,
965  SchemaVersion version)
966  : Base(data, numericCast<Base::BlockLength>(length), version)
967  {
968  assert(version >= Schema::MinimalVersion);
969  assert(length >= minimalBlockLength(version));
970  }
971 
972  /// Provides access to symbolIndex field.
974  bool symbolIndex(Uint32& value) const
976  {
978 
979  return ordinary(value, offset, NullUint32());
980  }
981 
982  /// Provides access to actionType field.
985  actionType() const
987  {
989 
990  return enumeration<MarketDataActionType>(offset);
991  }
992 
993  /// Provides access to orderPriority field.
995  bool orderPriority(Uint64& value) const
997  {
999 
1000  return ordinary(value, offset, NullUint64());
1001  }
1002 
1003  /// Provides access to previousPriority field.
1005  bool previousPriority(Uint64& value) const
1007  {
1009 
1010  return ordinary(value, offset, NullUint64());
1011  }
1012 
1013  /// Provides access to orderType field.
1015  bool orderType(OrderType::Enum& value) const
1017  {
1019 
1020  return enumeration<OrderType>(value, offset, NullUInt8());
1021  }
1022 
1023  /// Provides access to orderPx field.
1025  bool orderPx(Int64& value) const
1027  {
1029 
1030  return ordinary(value, offset, NullInt64());
1031  }
1032 
1033  /// Provides access to orderSide field.
1035  bool orderSide(OrderSide::Enum& value) const
1037  {
1039 
1040  return enumeration<OrderSide>(value, offset, NullUInt8());
1041  }
1042 
1043  /// Provides access to orderQuantity field.
1045  bool orderQuantity(Uint64& value) const
1047  {
1049 
1050  return ordinary(value, offset, NullUint64());
1051  }
1052 
1053  /// Provides access to pegOffset field.
1055  bool pegOffset(Int8& value) const
1057  {
1059 
1060  return ordinary(value, offset, NullInt8());
1061  }
1062 
1063  /// \return size of entry body in bytes
1064  /// for given version of message template.
1069  {
1070  return
1071  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1072  minimalBlockLength(version);
1073  }
1074 
1075  /// \return minimal size of entry body in bytes
1076  /// for given version of message template.
1079  static
1080  BlockLength
1084  {
1085  return
1086  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1087  40;
1088  }
1089 
1090  /// Entity class name.
1094  static const Char* className()
1095  {
1096  return "OrderUpdate.OrdersEntry";
1097  }
1098  };
1099 
1100  /// Repeating group containing OrdersEntry entries.
1101  typedef
1104 
1105  /// Initializes a blank instance.
1107 
1108  /// Creates an instance over the given memory block.
1110  const void* data,
1111  EncodedLength length)
1112  : SbeMessage(data, length)
1113  {
1114  checkCompatibility();
1115  }
1116 
1117  /// Creates an instance over the given SBE message.
1118  explicit
1120  const SbeMessage& message)
1121  : SbeMessage(message)
1122  {
1123  assert(message.valid());
1124 
1125  checkCompatibility();
1126  }
1127 
1128  /// Provides access to mDSeqNum field.
1130  bool seqNum(Uint64& value) const
1132  {
1134 
1135  return ordinary(value, offset, NullUint64());
1136  }
1137 
1138  /// Provides access to rebroadcastIndicator field.
1142  {
1144 
1145  return ordinary(value, offset, NullUnsignedChar());
1146  }
1147 
1148  /// Provides access to eMM field.
1150  Emm::Enum eMM() const
1152  {
1154 
1155  return enumeration<Emm>(offset);
1156  }
1157 
1158  /// Provides access to eventTime field.
1160  bool eventTime(Uint64& value) const
1162  {
1164 
1165  return ordinary(value, offset, NullUint64());
1166  }
1167 
1168  /// \return instance of Orders repeating group.
1170  Orders orders() const
1172  {
1173  return getGroup<Orders>(OrdersAccess(), *this);
1174  }
1175 
1176  /// Minimal size of message body in bytes.
1179  static
1180  BlockLength
1184  {
1185  return
1186  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1187  18;
1188  }
1189 
1190  /// Size of message body in bytes.
1195  {
1196  return
1197  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1198  minimalBlockLength(version);
1199  }
1200 
1201  /// Minimal variable fields size (when variable-length fields are empty).
1205  static
1206  MessageSize
1209  {
1210  return
1211  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1212  static_cast<MessageSize>(Orders::EmptySize);
1213  }
1214 
1215  /// \return class name.
1219  static const Char* className()
1220  {
1221  return "OrderUpdate";
1222  }
1223 
1224  /// FIX message type.
1228  static StrRef fixType()
1230  {
1231  return constructStrRef("OrderUpdate");
1232  }
1233 
1234  /// \return a human-readable presentation.
1236  std::string toString() const;
1237 
1238 private:
1239  void checkLength(
1240  EncodedLength length, SchemaVersion version) const
1241  {
1242  const EncodedLength minimalRequiredLength =
1243  minimalBlockLength(version) +
1244  MessageHeader::Size +
1245  getMinimalVariableFieldsSize(version);
1246 
1247  checkBinaryLength(
1248  *this, length, minimalRequiredLength);
1249  }
1250 
1251  /// Checks variable fields consistency.
1252  void checkVarLenFields() const
1253  {
1254  groups().
1255  checkTail<Orders>();
1256  }
1257 
1258  void checkCompatibility() const
1259  {
1260  assert(TemplateId == templateId());
1261 
1262  checkSchema<Schema>(schemaId(), version());
1263  checkLength(bufferSize(), version());
1264  checkVarLenFields();
1265  }
1266 
1267  /// Access helper.
1268  struct OrdersAccess
1269  {
1270  Orders operator()(const OrderUpdate& obj) const
1272  {
1273  return obj.
1274  groups().
1275  head<Orders>();
1276  }
1277  };
1278 };
1279 
1280 /// Message identifiers and length of message root.
1283 : SbeMessage
1284 {
1285  /// Used template schema.
1287 
1288  /// Message template ID from SBE schema.
1289  enum { TemplateId = 1003 };
1290 
1291  /// Repeating group dimensions.
1292  /// Entry of PricesEntry repeating group.
1295  <
1297  >
1298  {
1299  /// Base class type.
1300  typedef
1302  <
1304  >
1306 
1307  /// Initializes instance of given
1308  /// version over given memory block.
1310  const void* data,
1311  EncodedLength length,
1312  SchemaVersion version)
1313  : Base(data, numericCast<Base::BlockLength>(length), version)
1314  {
1315  assert(version >= Schema::MinimalVersion);
1316  assert(length >= minimalBlockLength(version));
1317  }
1318 
1319  /// Provides access to priceType field.
1322  priceType() const
1324  {
1326 
1327  return enumeration<MarketDataPriceType>(offset);
1328  }
1329 
1330  /// Provides access to symbolIndex field.
1332  bool symbolIndex(Uint32& value) const
1334  {
1336 
1337  return ordinary(value, offset, NullUint32());
1338  }
1339 
1340  /// Provides access to price field.
1342  bool price(Int64& value) const
1344  {
1346 
1347  return ordinary(value, offset, NullInt64());
1348  }
1349 
1350  /// Provides access to quantity field.
1352  bool quantity(Uint64& value) const
1354  {
1356 
1357  return ordinary(value, offset, NullUint64());
1358  }
1359 
1360  /// Provides access to imbalanceQty field.
1362  bool imbalanceQty(Uint64& value) const
1364  {
1366 
1367  return ordinary(value, offset, NullUint64());
1368  }
1369 
1370  /// Provides access to imbalanceQtySide field.
1372  bool
1374  ImbalanceQuantitySide::Enum& value) const
1376  {
1378 
1379  return enumeration<ImbalanceQuantitySide>(value, offset, NullUInt8());
1380  }
1381 
1382  /// Provides access to priceQualifier field.
1384  bool
1386  PriceQualifier::Enum& value) const
1388  {
1390 
1391  return enumeration<PriceQualifier>(value, offset, NullUInt8());
1392  }
1393 
1394  /// \return size of entry body in bytes
1395  /// for given version of message template.
1400  {
1401  return
1402  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1403  minimalBlockLength(version);
1404  }
1405 
1406  /// \return minimal size of entry body in bytes
1407  /// for given version of message template.
1410  static
1411  BlockLength
1415  {
1416  return
1417  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1418  31;
1419  }
1420 
1421  /// Entity class name.
1425  static const Char* className()
1426  {
1427  return "PriceUpdate.PricesEntry";
1428  }
1429  };
1430 
1431  /// Repeating group containing PricesEntry entries.
1432  typedef
1435 
1436  /// Initializes a blank instance.
1438 
1439  /// Creates an instance over the given memory block.
1441  const void* data,
1442  EncodedLength length)
1443  : SbeMessage(data, length)
1444  {
1445  checkCompatibility();
1446  }
1447 
1448  /// Creates an instance over the given SBE message.
1449  explicit
1451  const SbeMessage& message)
1452  : SbeMessage(message)
1453  {
1454  assert(message.valid());
1455 
1456  checkCompatibility();
1457  }
1458 
1459  /// Provides access to mDSeqNum field.
1461  bool seqNum(Uint64& value) const
1463  {
1465 
1466  return ordinary(value, offset, NullUint64());
1467  }
1468 
1469  /// Provides access to rebroadcastIndicator field.
1473  {
1475 
1476  return ordinary(value, offset, NullUnsignedChar());
1477  }
1478 
1479  /// Provides access to eMM field.
1481  Emm::Enum eMM() const
1483  {
1485 
1486  return enumeration<Emm>(offset);
1487  }
1488 
1489  /// Provides access to eventTime field.
1491  bool eventTime(Uint64& value) const
1493  {
1495 
1496  return ordinary(value, offset, NullUint64());
1497  }
1498 
1499  /// \return instance of Prices repeating group.
1501  Prices prices() const
1503  {
1504  return getGroup<Prices>(PricesAccess(), *this);
1505  }
1506 
1507  /// Minimal size of message body in bytes.
1510  static
1511  BlockLength
1515  {
1516  return
1517  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1518  18;
1519  }
1520 
1521  /// Size of message body in bytes.
1526  {
1527  return
1528  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1529  minimalBlockLength(version);
1530  }
1531 
1532  /// Minimal variable fields size (when variable-length fields are empty).
1536  static
1537  MessageSize
1540  {
1541  return
1542  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1543  static_cast<MessageSize>(Prices::EmptySize);
1544  }
1545 
1546  /// \return class name.
1550  static const Char* className()
1551  {
1552  return "PriceUpdate";
1553  }
1554 
1555  /// FIX message type.
1559  static StrRef fixType()
1561  {
1562  return constructStrRef("PriceUpdate");
1563  }
1564 
1565  /// \return a human-readable presentation.
1567  std::string toString() const;
1568 
1569 private:
1570  void checkLength(
1571  EncodedLength length, SchemaVersion version) const
1572  {
1573  const EncodedLength minimalRequiredLength =
1574  minimalBlockLength(version) +
1575  MessageHeader::Size +
1576  getMinimalVariableFieldsSize(version);
1577 
1578  checkBinaryLength(
1579  *this, length, minimalRequiredLength);
1580  }
1581 
1582  /// Checks variable fields consistency.
1583  void checkVarLenFields() const
1584  {
1585  groups().
1586  checkTail<Prices>();
1587  }
1588 
1589  void checkCompatibility() const
1590  {
1591  assert(TemplateId == templateId());
1592 
1593  checkSchema<Schema>(schemaId(), version());
1594  checkLength(bufferSize(), version());
1595  checkVarLenFields();
1596  }
1597 
1598  /// Access helper.
1599  struct PricesAccess
1600  {
1601  Prices operator()(const PriceUpdate& obj) const
1603  {
1604  return obj.
1605  groups().
1606  head<Prices>();
1607  }
1608  };
1609 };
1610 
1611 /// Message identifiers and length of message root.
1614 : SbeMessage
1615 {
1616  /// Used template schema.
1618 
1619  /// Message template ID from SBE schema.
1620  enum { TemplateId = 1004 };
1621 
1622  /// Repeating group dimensions.
1623  /// Entry of NotUsedGroup1Entry repeating group.
1626  <
1628  >
1629  {
1630  /// Base class type.
1631  typedef
1633  <
1635  >
1637 
1638  /// Initializes instance of given
1639  /// version over given memory block.
1641  const void* data,
1642  EncodedLength length,
1643  SchemaVersion version)
1644  : Base(data, numericCast<Base::BlockLength>(length), version)
1645  {
1646  assert(version >= Schema::MinimalVersion);
1647  assert(length >= minimalBlockLength(version));
1648  }
1649 
1650  /// \return size of entry body in bytes
1651  /// for given version of message template.
1656  {
1657  return
1658  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1659  minimalBlockLength(version);
1660  }
1661 
1662  /// \return minimal size of entry body in bytes
1663  /// for given version of message template.
1666  static
1667  BlockLength
1671  {
1672  return
1673  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1674  0;
1675  }
1676 
1677  /// Entity class name.
1681  static const Char* className()
1682  {
1683  return "FullTradeInformation.NotUsedGroup1Entry";
1684  }
1685  };
1686 
1687  /// Repeating group containing NotUsedGroup1Entry entries.
1688  typedef
1691 
1692  /// Initializes a blank instance.
1694 
1695  /// Creates an instance over the given memory block.
1697  const void* data,
1698  EncodedLength length)
1699  : SbeMessage(data, length)
1700  {
1701  checkCompatibility();
1702  }
1703 
1704  /// Creates an instance over the given SBE message.
1705  explicit
1707  const SbeMessage& message)
1708  : SbeMessage(message)
1709  {
1710  assert(message.valid());
1711 
1712  checkCompatibility();
1713  }
1714 
1715  /// Provides access to mDSeqNum field.
1717  bool seqNum(Uint64& value) const
1719  {
1721 
1722  return ordinary(value, offset, NullUint64());
1723  }
1724 
1725  /// Provides access to rebroadcastIndicator field.
1729  {
1731 
1732  return ordinary(value, offset, NullUnsignedChar());
1733  }
1734 
1735  /// Provides access to eMM field.
1737  Emm::Enum eMM() const
1739  {
1741 
1742  return enumeration<Emm>(offset);
1743  }
1744 
1745  /// Provides access to eventTime field.
1747  bool eventTime(Uint64& value) const
1749  {
1751 
1752  return ordinary(value, offset, NullUint64());
1753  }
1754 
1755  /// Provides access to symbolIndex field.
1757  bool symbolIndex(Uint32& value) const
1759  {
1761 
1762  return ordinary(value, offset, NullUint32());
1763  }
1764 
1765  /// Provides access to tradingDateTime field.
1769  {
1772 
1773  return fixedStr<length>(offset);
1774  }
1775 
1776  /// Provides access to publicationDateTime field.
1778  bool publicationDateTime(StrRef& value) const
1780  {
1783 
1784  return fixedStr<length>(value, offset);
1785  }
1786 
1787  /// Provides access to tradeType field.
1791  {
1793 
1794  return enumeration<TradeType>(offset);
1795  }
1796 
1797  /// Provides access to mifidInstrumentIdType field.
1799  bool mifidInstrumentIdType(StrRef& value) const
1801  {
1804 
1805  return fixedStr<length>(value, offset);
1806  }
1807 
1808  /// Provides access to mifidInstrumentID field.
1810  bool mifidInstrumentId(StrRef& value) const
1812  {
1815 
1816  return fixedStr<length>(value, offset);
1817  }
1818 
1819  /// Provides access to mifidExecutionID field.
1823  {
1826 
1827  return fixedStr<length>(offset);
1828  }
1829 
1830  /// Provides access to mifidPrice field.
1832  bool mifidPrice(StrRef& value) const
1834  {
1837 
1838  return fixedStr<length>(value, offset);
1839  }
1840 
1841  /// Provides access to mifidQuantity field.
1845  {
1848 
1849  return fixedStr<length>(offset);
1850  }
1851 
1852  /// Provides access to mifidPriceNotation field.
1854  bool mifidPriceNotation(StrRef& value) const
1856  {
1859 
1860  return fixedStr<length>(value, offset);
1861  }
1862 
1863  /// Provides access to mifidCurrency field.
1865  bool mifidCurrency(StrRef& value) const
1867  {
1870 
1871  return fixedStr<length>(value, offset);
1872  }
1873 
1874  /// Provides access to miFIDQtyinMsrmtUnitNotation field.
1878  {
1881 
1882  return fixedStr<length>(value, offset);
1883  }
1884 
1885  /// Provides access to mifidQuantityMeasurementUnit field.
1889  {
1892 
1893  return fixedStr<length>(value, offset);
1894  }
1895 
1896  /// Provides access to miFIDNotionalAmount field.
1898  bool miFIdNotionalAmount(StrRef& value) const
1900  {
1903 
1904  return fixedStr<length>(value, offset);
1905  }
1906 
1907  /// Provides access to notionalCurrency field.
1909  bool notionalCurrency(StrRef& value) const
1911  {
1914 
1915  return fixedStr<length>(value, offset);
1916  }
1917 
1918  /// Provides access to miFIDClearingFlag field.
1920  bool miFIdClearingFlag(StrRef& value) const
1922  {
1925 
1926  return fixedStr<length>(value, offset);
1927  }
1928 
1929  /// Provides access to mMTMarketMechanism field.
1931  bool
1933  MmtMarketMechanism::Enum& value) const
1935  {
1937 
1938  return enumeration<MmtMarketMechanism>(value, offset, NullUInt8());
1939  }
1940 
1941  /// Provides access to mMTTradingMode field.
1943  bool
1945  MmtTradingMode::Enum& value) const
1947  {
1949 
1950  return enumeration<MmtTradingMode>(value, offset, NullChar());
1951  }
1952 
1953  /// Provides access to mMTTransactionCategory field.
1955  bool mMTTransactionCategory(StrRef& value) const
1957  {
1960 
1961  return fixedStr<length>(value, offset);
1962  }
1963 
1964  /// Provides access to mMTNegotiationIndicator field.
1966  bool mMTNegotiationIndicator(StrRef& value) const
1968  {
1971 
1972  return fixedStr<length>(value, offset);
1973  }
1974 
1975  /// Provides access to mMTAgencyCrossTradeIndicator field.
1979  {
1982 
1983  return fixedStr<length>(value, offset);
1984  }
1985 
1986  /// Provides access to mMTModificationIndicator field.
1990  {
1993 
1994  return fixedStr<length>(value, offset);
1995  }
1996 
1997  /// Provides access to mMTBenchmarkIndicator field.
1999  bool mMTBenchmarkIndicator(StrRef& value) const
2001  {
2004 
2005  return fixedStr<length>(value, offset);
2006  }
2007 
2008  /// Provides access to mMTSpecialDividendIndicator field.
2012  {
2015 
2016  return fixedStr<length>(value, offset);
2017  }
2018 
2019  /// Provides access to mMTOffBookAutomatedIndicator field.
2021  bool
2025  {
2027 
2028  return enumeration<MmtOffBookAutomatedIndicator>(value, offset, NullChar());
2029  }
2030 
2031  /// Provides access to mMTContributiontoPrice field.
2033  bool mMTContributiontoPrice(StrRef& value) const
2035  {
2038 
2039  return fixedStr<length>(value, offset);
2040  }
2041 
2042  /// Provides access to mMTAlgorithmicIndicator field.
2044  bool mMTAlgorithmicIndicator(StrRef& value) const
2046  {
2049 
2050  return fixedStr<length>(value, offset);
2051  }
2052 
2053  /// Provides access to mMTPublicationMode field.
2055  bool mMTPublicationMode(StrRef& value) const
2057  {
2060 
2061  return fixedStr<length>(value, offset);
2062  }
2063 
2064  /// Provides access to mMTPostTradeDeferral field.
2066  bool mMTPostTradeDeferral(StrRef& value) const
2068  {
2071 
2072  return fixedStr<length>(value, offset);
2073  }
2074 
2075  /// Provides access to mMTDuplicativeIndicator field.
2077  bool mMTDuplicativeIndicator(StrRef& value) const
2079  {
2082 
2083  return fixedStr<length>(value, offset);
2084  }
2085 
2086  /// Provides access to tradeQualifier field.
2090  {
2092 
2093  return ordinary<TradeQualifier>(offset);
2094  }
2095 
2096  /// Provides access to transactionType field.
2098  bool
2100  TransactionType::Enum& value) const
2102  {
2104 
2105  return enumeration<TransactionType>(value, offset, NullUInt8());
2106  }
2107 
2108  /// Provides access to effectiveDateIndicator field.
2110  bool
2112  EffectiveDateIndicator::Enum& value) const
2114  {
2116 
2117  return enumeration<EffectiveDateIndicator>(value, offset, NullUInt8());
2118  }
2119 
2120  /// Provides access to blockTradeCode field.
2122  bool
2124  BlockTradeCode::Enum& value) const
2126  {
2128 
2129  return enumeration<BlockTradeCode>(value, offset, NullChar());
2130  }
2131 
2132  /// Provides access to tradeReference field.
2134  bool tradeReference(StrRef& value) const
2136  {
2139 
2140  return fixedStr<length>(value, offset);
2141  }
2142 
2143  /// Provides access to originalReportTimestamp field.
2145  bool originalReportTimestamp(Uint64& value) const
2147  {
2149 
2150  return ordinary(value, offset, NullUint64());
2151  }
2152 
2153  /// Provides access to transparencyIndicator field.
2155  bool
2157  TransparencyIndicator::Enum& value) const
2159  {
2161 
2162  return enumeration<TransparencyIndicator>(value, offset, NullUInt8());
2163  }
2164 
2165  /// Provides access to currencyCoefficient field.
2167  bool currencyCoefficient(Uint32& value) const
2169  {
2171 
2172  return ordinary(value, offset, NullUint32());
2173  }
2174 
2175  /// Provides access to priceMultiplier field.
2177  bool priceMultiplier(Uint32& value) const
2179  {
2181 
2182  return ordinary(value, offset, NullUint32());
2183  }
2184 
2185  /// Provides access to priceMultiplierDecimals field.
2189  {
2191 
2192  return ordinary(value, offset, NullUnsignedChar());
2193  }
2194 
2195  /// Provides access to venue field.
2197  StrRef venue() const
2199  {
2202 
2203  return fixedStr<length>(offset);
2204  }
2205 
2206  /// Provides access to startTimeVwap field.
2208  bool startTimeVwap(Uint32& value) const
2210  {
2212 
2213  return ordinary(value, offset, NullUint32());
2214  }
2215 
2216  /// Provides access to endTimeVwap field.
2218  bool endTimeVwap(Uint32& value) const
2220  {
2222 
2223  return ordinary(value, offset, NullUint32());
2224  }
2225 
2226  /// Provides access to miFIDEmissionAllowanceType field.
2230  {
2233 
2234  return fixedStr<length>(value, offset);
2235  }
2236 
2237  /// Provides access to marketOfReferenceMIC field.
2239  bool marketOfReferenceMIC(StrRef& value) const
2241  {
2244 
2245  return fixedStr<length>(value, offset);
2246  }
2247 
2248  /// Provides access to evaluatedPrice field.
2250  bool evaluatedPrice(Int64& value) const
2252  {
2254 
2255  return ordinary(value, offset, NullInt64());
2256  }
2257 
2258  /// Provides access to messagePriceNotation field.
2260  bool
2262  MessagePriceNotation::Enum& value) const
2264  {
2266 
2267  return enumeration<MessagePriceNotation>(value, offset, NullUInt8());
2268  }
2269 
2270  /// Provides access to settlementDate field.
2272  bool settlementDate(Uint16& value) const
2274  {
2276 
2277  return ordinary(value, offset, NullUint16());
2278  }
2279 
2280  /// Provides access to repoSettlementDate field.
2282  bool repoSettlementDate(Uint16& value) const
2284  {
2286 
2287  return ordinary(value, offset, NullUint16());
2288  }
2289 
2290  /// Provides access to tradeUniqueIdentifier field.
2292  bool tradeUniqueIdentifier(StrRef& value) const
2294  {
2298 
2299  return fixedStr<length>(value, offset, since);
2300  }
2301 
2302  /// Provides access to missingPrice field.
2304  bool missingPrice(StrRef& value) const
2306  {
2310 
2311  return fixedStr<length>(value, offset, since);
2312  }
2313 
2314  /// Provides access to mMTPreTradeTransparencyWaiverRelatedtoSizeandScale field.
2318  {
2322 
2323  return fixedStr<length>(value, offset, since);
2324  }
2325 
2326  /// Provides access to mMTPortfolioTransactionIndicator field.
2330  {
2334 
2335  return fixedStr<length>(value, offset, since);
2336  }
2337 
2338  /// Provides access to mMTContingentTransactionIndicator field.
2342  {
2346 
2347  return fixedStr<length>(value, offset, since);
2348  }
2349 
2350  /// Provides access to mMTPublicationModeIlliquid field.
2354  {
2358 
2359  return fixedStr<length>(value, offset, since);
2360  }
2361 
2362  /// Provides access to mMTPublicationModeSizeSpecific field.
2366  {
2370 
2371  return fixedStr<length>(value, offset, since);
2372  }
2373 
2374  /// Provides access to venueofPublication field.
2376  bool venueofPublication(StrRef& value) const
2378  {
2382 
2383  return fixedStr<length>(value, offset, since);
2384  }
2385 
2386  /// Provides access to postTradeDeferralFlags field.
2388  bool postTradeDeferralFlags(StrRef& value) const
2390  {
2394 
2395  return fixedStr<length>(value, offset, since);
2396  }
2397 
2398  /// \return instance of NotUsedGroup1 repeating group.
2402  {
2403  return getGroup<NotUsedGroup1>(
2404  NotUsedGroup1Access(),
2405  *this);
2406  }
2407 
2408  /// Minimal size of message body in bytes.
2413  {
2414  return
2415  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2416  (version >= 353)
2417  ? 452
2418  : (version >= 334)
2419  ? 444
2420  : (version >= 316)
2421  ? 420
2422  : 404;
2423  }
2424 
2425  /// Size of message body in bytes.
2430  {
2431  return
2432  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2433  minimalBlockLength(version);
2434  }
2435 
2436  /// Minimal variable fields size (when variable-length fields are empty).
2440  static
2441  MessageSize
2444  {
2445  return
2446  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2447  static_cast<MessageSize>(NotUsedGroup1::EmptySize);
2448  }
2449 
2450  /// \return class name.
2454  static const Char* className()
2455  {
2456  return "FullTradeInformation";
2457  }
2458 
2459  /// FIX message type.
2463  static StrRef fixType()
2465  {
2466  return constructStrRef("FullTradeInformation");
2467  }
2468 
2469  /// \return a human-readable presentation.
2471  std::string toString() const;
2472 
2473 private:
2474  void checkLength(
2475  EncodedLength length, SchemaVersion version) const
2476  {
2477  const EncodedLength minimalRequiredLength =
2478  minimalBlockLength(version) +
2479  MessageHeader::Size +
2480  getMinimalVariableFieldsSize(version);
2481 
2482  checkBinaryLength(
2483  *this, length, minimalRequiredLength);
2484  }
2485 
2486  /// Checks variable fields consistency.
2487  void checkVarLenFields() const
2488  {
2489  groups().
2490  checkTail<NotUsedGroup1>();
2491  }
2492 
2493  void checkCompatibility() const
2494  {
2495  assert(TemplateId == templateId());
2496 
2497  checkSchema<Schema>(schemaId(), version());
2498  checkLength(bufferSize(), version());
2499  checkVarLenFields();
2500  }
2501 
2502  /// Access helper.
2503  struct NotUsedGroup1Access
2504  {
2506  operator()(
2507  const FullTradeInformation& obj) const
2509  {
2510  return obj.
2511  groups().
2512  head<NotUsedGroup1>();
2513  }
2514  };
2515 };
2516 
2517 /// Message identifiers and length of message root.
2520 : SbeMessage
2521 {
2522  /// Used template schema.
2524 
2525  /// Message template ID from SBE schema.
2526  enum { TemplateId = 1005 };
2527 
2528  /// Repeating group dimensions.
2529  /// Entry of MarketStatesEntry repeating group.
2532  <
2534  >
2535  {
2536  /// Base class type.
2537  typedef
2539  <
2541  >
2543 
2544  /// Initializes instance of given
2545  /// version over given memory block.
2547  const void* data,
2548  EncodedLength length,
2549  SchemaVersion version)
2550  : Base(data, numericCast<Base::BlockLength>(length), version)
2551  {
2552  assert(version >= Schema::MinimalVersion);
2553  assert(length >= minimalBlockLength(version));
2554  }
2555 
2556  /// Provides access to changeType field.
2559  changeType() const
2561  {
2563 
2564  return enumeration<MarketDataChangeType>(offset);
2565  }
2566 
2567  /// Provides access to symbolIndex field.
2569  bool symbolIndex(Uint32& value) const
2571  {
2573 
2574  return ordinary(value, offset, NullUint32());
2575  }
2576 
2577  /// Provides access to eventTime field.
2579  bool eventTime(Uint64& value) const
2581  {
2583 
2584  return ordinary(value, offset, NullUint64());
2585  }
2586 
2587  /// Provides access to bookState field.
2589  bool bookState(BookState::Enum& value) const
2591  {
2593 
2594  return enumeration<BookState>(value, offset, NullUInt8());
2595  }
2596 
2597  /// Provides access to statusReason field.
2599  bool
2601  StatusReason::Enum& value) const
2603  {
2605 
2606  return enumeration<StatusReason>(value, offset, NullUInt8());
2607  }
2608 
2609  /// Provides access to phaseQualifier field.
2613  {
2615 
2616  return ordinary<PhaseQualifier>(offset);
2617  }
2618 
2619  /// Provides access to tradingPeriod field.
2621  bool
2623  TradingPeriod::Enum& value) const
2625  {
2627 
2628  return enumeration<TradingPeriod>(value, offset, NullUInt8());
2629  }
2630 
2631  /// Provides access to tradingSide field.
2633  bool tradingSide(TradingSide::Enum& value) const
2635  {
2637 
2638  return enumeration<TradingSide>(value, offset, NullUInt8());
2639  }
2640 
2641  /// Provides access to priceLimits field.
2643  bool priceLimits(PriceLimits::Enum& value) const
2645  {
2647 
2648  return enumeration<PriceLimits>(value, offset, NullUInt8());
2649  }
2650 
2651  /// Provides access to quoteSpreadMultiplier field.
2653  bool
2655  QuoteSpreadMultiplier::Enum& value) const
2657  {
2659 
2660  return enumeration<QuoteSpreadMultiplier>(value, offset, NullUInt8());
2661  }
2662 
2663  /// Provides access to orderEntryQualifier field.
2665  bool
2667  OrderEntryQualifier::Enum& value) const
2669  {
2671 
2672  return enumeration<OrderEntryQualifier>(value, offset, NullUInt8());
2673  }
2674 
2675  /// Provides access to session field.
2679  {
2681 
2682  return enumeration<Session>(offset);
2683  }
2684 
2685  /// Provides access to scheduledEvent field.
2687  bool
2689  ScheduledEvent::Enum& value) const
2691  {
2693 
2694  return enumeration<ScheduledEvent>(value, offset, NullUInt8());
2695  }
2696 
2697  /// Provides access to scheduledEventTime field.
2699  bool scheduledEventTime(Uint64& value) const
2701  {
2703 
2704  return ordinary(value, offset, NullUint64());
2705  }
2706 
2707  /// Provides access to instrumentState field.
2709  bool
2711  InstrumentState::Enum& value) const
2713  {
2715 
2716  return enumeration<InstrumentState>(value, offset, NullUInt8());
2717  }
2718 
2719  /// \return size of entry body in bytes
2720  /// for given version of message template.
2725  {
2726  return
2727  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2728  minimalBlockLength(version);
2729  }
2730 
2731  /// \return minimal size of entry body in bytes
2732  /// for given version of message template.
2735  static
2736  BlockLength
2740  {
2741  return
2742  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2743  33;
2744  }
2745 
2746  /// Entity class name.
2750  static const Char* className()
2751  {
2752  return "MarketStatusChange.MarketStatesEntry";
2753  }
2754  };
2755 
2756  /// Repeating group containing MarketStatesEntry entries.
2757  typedef
2760 
2761  /// Initializes a blank instance.
2763 
2764  /// Creates an instance over the given memory block.
2766  const void* data,
2767  EncodedLength length)
2768  : SbeMessage(data, length)
2769  {
2770  checkCompatibility();
2771  }
2772 
2773  /// Creates an instance over the given SBE message.
2774  explicit
2776  const SbeMessage& message)
2777  : SbeMessage(message)
2778  {
2779  assert(message.valid());
2780 
2781  checkCompatibility();
2782  }
2783 
2784  /// Provides access to mDSeqNum field.
2786  bool seqNum(Uint64& value) const
2788  {
2790 
2791  return ordinary(value, offset, NullUint64());
2792  }
2793 
2794  /// Provides access to rebroadcastIndicator field.
2798  {
2800 
2801  return ordinary(value, offset, NullUnsignedChar());
2802  }
2803 
2804  /// Provides access to eMM field.
2806  Emm::Enum eMM() const
2808  {
2810 
2811  return enumeration<Emm>(offset);
2812  }
2813 
2814  /// \return instance of MarketStates repeating group.
2818  {
2819  return getGroup<MarketStates>(
2820  MarketStatesAccess(),
2821  *this);
2822  }
2823 
2824  /// Minimal size of message body in bytes.
2827  static
2828  BlockLength
2832  {
2833  return
2834  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2835  10;
2836  }
2837 
2838  /// Size of message body in bytes.
2843  {
2844  return
2845  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2846  minimalBlockLength(version);
2847  }
2848 
2849  /// Minimal variable fields size (when variable-length fields are empty).
2853  static
2854  MessageSize
2857  {
2858  return
2859  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2860  static_cast<MessageSize>(MarketStates::EmptySize);
2861  }
2862 
2863  /// \return class name.
2867  static const Char* className()
2868  {
2869  return "MarketStatusChange";
2870  }
2871 
2872  /// FIX message type.
2876  static StrRef fixType()
2878  {
2879  return constructStrRef("MarketStatusChange");
2880  }
2881 
2882  /// \return a human-readable presentation.
2884  std::string toString() const;
2885 
2886 private:
2887  void checkLength(
2888  EncodedLength length, SchemaVersion version) const
2889  {
2890  const EncodedLength minimalRequiredLength =
2891  minimalBlockLength(version) +
2892  MessageHeader::Size +
2893  getMinimalVariableFieldsSize(version);
2894 
2895  checkBinaryLength(
2896  *this, length, minimalRequiredLength);
2897  }
2898 
2899  /// Checks variable fields consistency.
2900  void checkVarLenFields() const
2901  {
2902  groups().
2903  checkTail<MarketStates>();
2904  }
2905 
2906  void checkCompatibility() const
2907  {
2908  assert(TemplateId == templateId());
2909 
2910  checkSchema<Schema>(schemaId(), version());
2911  checkLength(bufferSize(), version());
2912  checkVarLenFields();
2913  }
2914 
2915  /// Access helper.
2916  struct MarketStatesAccess
2917  {
2918  MarketStates
2919  operator()(
2920  const MarketStatusChange& obj) const
2922  {
2923  return obj.
2924  groups().
2925  head<MarketStates>();
2926  }
2927  };
2928 };
2929 
2930 /// Message identifiers and length of message root.
2932 Timetable
2933 : SbeMessage
2934 {
2935  /// Used template schema.
2937 
2938  /// Message template ID from SBE schema.
2939  enum { TemplateId = 1006 };
2940 
2941  /// Repeating group dimensions.
2942  /// Entry of TimetablesEntry repeating group.
2945  <
2947  >
2948  {
2949  /// Base class type.
2950  typedef
2952  <
2954  >
2956 
2957  /// Initializes instance of given
2958  /// version over given memory block.
2960  const void* data,
2961  EncodedLength length,
2962  SchemaVersion version)
2963  : Base(data, numericCast<Base::BlockLength>(length), version)
2964  {
2965  assert(version >= Schema::MinimalVersion);
2966  assert(length >= minimalBlockLength(version));
2967  }
2968 
2969  /// Provides access to phaseTime field.
2971  bool phaseTime(Uint64& value) const
2973  {
2975 
2976  return ordinary(value, offset, NullUint64());
2977  }
2978 
2979  /// Provides access to phaseId field.
2983  {
2985 
2986  return enumeration<PhaseId>(offset);
2987  }
2988 
2989  /// Provides access to phaseQualifier field.
2993  {
2995 
2996  return ordinary<PhaseQualifier>(offset);
2997  }
2998 
2999  /// Provides access to tradingPeriod field.
3003  {
3005 
3006  return enumeration<TradingPeriod>(offset);
3007  }
3008 
3009  /// Provides access to orderEntryQualifier field.
3011  bool
3013  OrderEntryQualifier::Enum& value) const
3015  {
3017 
3018  return enumeration<OrderEntryQualifier>(value, offset, NullUInt8());
3019  }
3020 
3021  /// Provides access to session field.
3025  {
3027 
3028  return enumeration<Session>(offset);
3029  }
3030 
3031  /// Provides access to scheduledEvent field.
3033  bool
3035  ScheduledEvent::Enum& value) const
3037  {
3039 
3040  return enumeration<ScheduledEvent>(value, offset, NullUInt8());
3041  }
3042 
3043  /// \return size of entry body in bytes
3044  /// for given version of message template.
3049  {
3050  return
3051  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3052  minimalBlockLength(version);
3053  }
3054 
3055  /// \return minimal size of entry body in bytes
3056  /// for given version of message template.
3059  static
3060  BlockLength
3064  {
3065  return
3066  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3067  15;
3068  }
3069 
3070  /// Entity class name.
3074  static const Char* className()
3075  {
3076  return "Timetable.TimetablesEntry";
3077  }
3078  };
3079 
3080  /// Repeating group containing TimetablesEntry entries.
3081  typedef
3084 
3085  /// Initializes a blank instance.
3087 
3088  /// Creates an instance over the given memory block.
3090  const void* data,
3091  EncodedLength length)
3092  : SbeMessage(data, length)
3093  {
3094  checkCompatibility();
3095  }
3096 
3097  /// Creates an instance over the given SBE message.
3098  explicit
3100  const SbeMessage& message)
3101  : SbeMessage(message)
3102  {
3103  assert(message.valid());
3104 
3105  checkCompatibility();
3106  }
3107 
3108  /// Provides access to mDSeqNum field.
3110  bool seqNum(Uint64& value) const
3112  {
3114 
3115  return ordinary(value, offset, NullUint64());
3116  }
3117 
3118  /// Provides access to rebroadcastIndicator field.
3122  {
3124 
3125  return ordinary(value, offset, NullUnsignedChar());
3126  }
3127 
3128  /// Provides access to eMM field.
3130  bool eMM(Emm::Enum& value) const
3132  {
3134 
3135  return enumeration<Emm>(value, offset, NullUInt8());
3136  }
3137 
3138  /// Provides access to patternID field.
3140  bool patternId(Uint16& value) const
3142  {
3144 
3145  return ordinary(value, offset, NullUint16());
3146  }
3147 
3148  /// Provides access to symbolIndex field.
3150  bool symbolIndex(Uint32& value) const
3152  {
3154 
3155  return ordinary(value, offset, NullUint32());
3156  }
3157 
3158  /// \return instance of Timetables repeating group.
3162  {
3163  return getGroup<Timetables>(
3164  TimetablesAccess(),
3165  *this);
3166  }
3167 
3168  /// Minimal size of message body in bytes.
3171  static
3172  BlockLength
3176  {
3177  return
3178  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3179  16;
3180  }
3181 
3182  /// Size of message body in bytes.
3187  {
3188  return
3189  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3190  minimalBlockLength(version);
3191  }
3192 
3193  /// Minimal variable fields size (when variable-length fields are empty).
3197  static
3198  MessageSize
3201  {
3202  return
3203  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3204  static_cast<MessageSize>(Timetables::EmptySize);
3205  }
3206 
3207  /// \return class name.
3211  static const Char* className()
3212  {
3213  return "Timetable";
3214  }
3215 
3216  /// FIX message type.
3220  static StrRef fixType()
3222  {
3223  return constructStrRef("Timetable");
3224  }
3225 
3226  /// \return a human-readable presentation.
3228  std::string toString() const;
3229 
3230 private:
3231  void checkLength(
3232  EncodedLength length, SchemaVersion version) const
3233  {
3234  const EncodedLength minimalRequiredLength =
3235  minimalBlockLength(version) +
3236  MessageHeader::Size +
3237  getMinimalVariableFieldsSize(version);
3238 
3239  checkBinaryLength(
3240  *this, length, minimalRequiredLength);
3241  }
3242 
3243  /// Checks variable fields consistency.
3244  void checkVarLenFields() const
3245  {
3246  groups().
3247  checkTail<Timetables>();
3248  }
3249 
3250  void checkCompatibility() const
3251  {
3252  assert(TemplateId == templateId());
3253 
3254  checkSchema<Schema>(schemaId(), version());
3255  checkLength(bufferSize(), version());
3256  checkVarLenFields();
3257  }
3258 
3259  /// Access helper.
3260  struct TimetablesAccess
3261  {
3262  Timetables operator()(const Timetable& obj) const
3264  {
3265  return obj.
3266  groups().
3267  head<Timetables>();
3268  }
3269  };
3270 };
3271 
3272 /// Message identifiers and length of message root.
3275 : SbeMessage
3276 {
3277  /// Used template schema.
3279 
3280  /// Message template ID from SBE schema.
3281  enum { TemplateId = 1007 };
3282 
3283  /// Repeating group dimensions.
3284  /// Entry of EmmPatternRepEntry repeating group.
3287  <
3289  >
3290  {
3291  /// Base class type.
3292  typedef
3294  <
3296  >
3298 
3299  /// Initializes instance of given
3300  /// version over given memory block.
3302  const void* data,
3303  EncodedLength length,
3304  SchemaVersion version)
3305  : Base(data, numericCast<Base::BlockLength>(length), version)
3306  {
3307  assert(version >= Schema::MinimalVersion);
3308  assert(length >= minimalBlockLength(version));
3309  }
3310 
3311  /// Provides access to eMM field.
3313  Emm::Enum eMM() const
3315  {
3317 
3318  return enumeration<Emm>(offset);
3319  }
3320 
3321  /// Provides access to patternID field.
3323  bool patternId(Uint16& value) const
3325  {
3327 
3328  return ordinary(value, offset, NullUint16());
3329  }
3330 
3331  /// Provides access to tickSizeIndexID field.
3333  bool tickSizeIndexId(Uint16& value) const
3335  {
3337 
3338  return ordinary(value, offset, NullUint16());
3339  }
3340 
3341  /// Provides access to marketModel field.
3343  bool marketModel(MarketModel::Enum& value) const
3345  {
3347 
3348  return enumeration<MarketModel>(value, offset, NullUInt8());
3349  }
3350 
3351  /// Provides access to lotSize field.
3353  bool lotSize(Uint64& value) const
3355  {
3357 
3358  return ordinary(value, offset, NullUint64());
3359  }
3360 
3361  /// Provides access to instUnitExp field.
3363  bool
3365  InstrumentUnitExpression::Enum& value) const
3367  {
3369 
3370  return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
3371  }
3372 
3373  /// Provides access to anonymous field.
3375  bool anonymous(Anonymous::Enum& value) const
3377  {
3379 
3380  return enumeration<Anonymous>(value, offset, NullUInt8());
3381  }
3382 
3383  /// \return size of entry body in bytes
3384  /// for given version of message template.
3389  {
3390  return
3391  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3392  minimalBlockLength(version);
3393  }
3394 
3395  /// \return minimal size of entry body in bytes
3396  /// for given version of message template.
3399  static
3400  BlockLength
3404  {
3405  return
3406  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3407  16;
3408  }
3409 
3410  /// Entity class name.
3414  static const Char* className()
3415  {
3416  return "StandingData.EmmPatternRepEntry";
3417  }
3418  };
3419 
3420  /// Repeating group containing EmmPatternRepEntry entries.
3421  typedef
3424 
3425  /// Initializes a blank instance.
3427 
3428  /// Creates an instance over the given memory block.
3430  const void* data,
3431  EncodedLength length)
3432  : SbeMessage(data, length)
3433  {
3434  checkCompatibility();
3435  }
3436 
3437  /// Creates an instance over the given SBE message.
3438  explicit
3440  const SbeMessage& message)
3441  : SbeMessage(message)
3442  {
3443  assert(message.valid());
3444 
3445  checkCompatibility();
3446  }
3447 
3448  /// Provides access to mDSeqNum field.
3450  bool seqNum(Uint64& value) const
3452  {
3454 
3455  return ordinary(value, offset, NullUint64());
3456  }
3457 
3458  /// Provides access to rebroadcastIndicator field.
3462  {
3464 
3465  return ordinary(value, offset, NullUnsignedChar());
3466  }
3467 
3468  /// Provides access to symbolIndex field.
3470  bool symbolIndex(Uint32& value) const
3472  {
3474 
3475  return ordinary(value, offset, NullUint32());
3476  }
3477 
3478  /// Provides access to optiqSegment field.
3482  {
3484 
3485  return enumeration<OptiqSegment>(offset);
3486  }
3487 
3488  /// Provides access to partitionID field.
3490  bool partitionId(Uint16& value) const
3492  {
3494 
3495  return ordinary(value, offset, NullUint16());
3496  }
3497 
3498  /// Provides access to fullInstrumentName field.
3500  bool fullInstrumentName(StrRef& value) const
3502  {
3505 
3506  return fixedStr<length>(value, offset);
3507  }
3508 
3509  /// Provides access to instrumentName field.
3513  {
3516 
3517  return fixedStr<length>(offset);
3518  }
3519 
3520  /// Provides access to instrumentTradingCode field.
3522  bool instrumentTradingCode(StrRef& value) const
3524  {
3527 
3528  return fixedStr<length>(value, offset);
3529  }
3530 
3531  /// Provides access to instrumentGroupCode field.
3535  {
3538 
3539  return fixedStr<length>(offset);
3540  }
3541 
3542  /// Provides access to iSINCode field.
3546  {
3549 
3550  return fixedStr<length>(offset);
3551  }
3552 
3553  /// Provides access to priceDecimals field.
3555  bool priceDecimals(UnsignedChar& value) const
3557  {
3559 
3560  return ordinary(value, offset, NullUnsignedChar());
3561  }
3562 
3563  /// Provides access to quantityDecimals field.
3565  bool quantityDecimals(UnsignedChar& value) const
3567  {
3569 
3570  return ordinary(value, offset, NullUnsignedChar());
3571  }
3572 
3573  /// Provides access to amountDecimals field.
3575  bool amountDecimals(UnsignedChar& value) const
3577  {
3579 
3580  return ordinary(value, offset, NullUnsignedChar());
3581  }
3582 
3583  /// Provides access to ratioDecimals field.
3585  bool ratioDecimals(UnsignedChar& value) const
3587  {
3589 
3590  return ordinary(value, offset, NullUnsignedChar());
3591  }
3592 
3593  /// Provides access to cFI field.
3595  StrRef cFI() const
3597  {
3600 
3601  return fixedStr<length>(offset);
3602  }
3603 
3604  /// Provides access to instrumentEventDate field.
3606  bool instrumentEventDate(Uint16& value) const
3608  {
3610 
3611  return ordinary(value, offset, NullUint16());
3612  }
3613 
3614  /// Provides access to strikePrice field.
3616  bool strikePrice(Int64& value) const
3618  {
3620 
3621  return ordinary(value, offset, NullInt64());
3622  }
3623 
3624  /// Provides access to darkEligibility field.
3626  bool darkEligibility(UnsignedChar& value) const
3628  {
3630 
3631  return ordinary(value, offset, NullUnsignedChar());
3632  }
3633 
3634  /// Provides access to darkLISThreshold field.
3636  bool darkLISThreshold(Uint64& value) const
3638  {
3640 
3641  return ordinary(value, offset, NullUint64());
3642  }
3643 
3644  /// Provides access to darkMinQuantity field.
3646  bool darkMinQuantity(Uint32& value) const
3648  {
3650 
3651  return ordinary(value, offset, NullUint32());
3652  }
3653 
3654  /// Provides access to dateOfLastTrade field.
3656  bool dateOfLastTrade(Uint16& value) const
3658  {
3660 
3661  return ordinary(value, offset, NullUint16());
3662  }
3663 
3664  /// Provides access to depositaryList field.
3666  bool depositaryList(StrRef& value) const
3668  {
3671 
3672  return fixedStr<length>(value, offset);
3673  }
3674 
3675  /// Provides access to mainDepositary field.
3677  bool mainDepositary(StrRef& value) const
3679  {
3682 
3683  return fixedStr<length>(value, offset);
3684  }
3685 
3686  /// Provides access to firstSettlementDate field.
3688  bool firstSettlementDate(Uint16& value) const
3690  {
3692 
3693  return ordinary(value, offset, NullUint16());
3694  }
3695 
3696  /// Provides access to guaranteeIndicator field.
3698  bool
3700  GuaranteeIndicator::Enum& value) const
3702  {
3704 
3705  return enumeration<GuaranteeIndicator>(value, offset, NullUInt8());
3706  }
3707 
3708  /// Provides access to iCB field.
3710  bool iCB(StrRef& value) const
3712  {
3715 
3716  return fixedStr<length>(value, offset);
3717  }
3718 
3719  /// Provides access to issuingCountry field.
3721  bool issuingCountry(StrRef& value) const
3723  {
3726 
3727  return fixedStr<length>(value, offset);
3728  }
3729 
3730  /// Provides access to lastAdjustedClosingPrice field.
3732  bool lastAdjustedClosingPrice(Int64& value) const
3734  {
3736 
3737  return ordinary(value, offset, NullInt64());
3738  }
3739 
3740  /// Provides access to lotSize field.
3742  bool lotSize(Uint64& value) const
3744  {
3746 
3747  return ordinary(value, offset, NullUint64());
3748  }
3749 
3750  /// Provides access to maturityDate field.
3752  bool maturityDate(StrRef& value) const
3754  {
3757 
3758  return fixedStr<length>(value, offset);
3759  }
3760 
3761  /// Provides access to maximumDecimalsInQuantity field.
3765  {
3767 
3768  return ordinary(value, offset, NullUnsignedChar());
3769  }
3770 
3771  /// Provides access to mIC field.
3773  StrRef mIC() const
3775  {
3778 
3779  return fixedStr<length>(offset);
3780  }
3781 
3782  /// Provides access to mICList field.
3784  bool mICList(StrRef& value) const
3786  {
3789 
3790  return fixedStr<length>(value, offset);
3791  }
3792 
3793  /// Provides access to countryOfExchange field.
3795  bool countryOfExchange(StrRef& value) const
3797  {
3800 
3801  return fixedStr<length>(value, offset);
3802  }
3803 
3804  /// Provides access to mnemonic field.
3806  bool mnemonic(StrRef& value) const
3808  {
3811 
3812  return fixedStr<length>(value, offset);
3813  }
3814 
3815  /// Provides access to underlyingMIC field.
3817  bool underlyingMIC(StrRef& value) const
3819  {
3822 
3823  return fixedStr<length>(value, offset);
3824  }
3825 
3826  /// Provides access to underlyingISINCode field.
3828  bool underlyingISINCode(StrRef& value) const
3830  {
3833 
3834  return fixedStr<length>(value, offset);
3835  }
3836 
3837  /// Provides access to tradingCurrency field.
3839  bool tradingCurrency(StrRef& value) const
3841  {
3844 
3845  return fixedStr<length>(value, offset);
3846  }
3847 
3848  /// Provides access to currencyCoefficient field.
3850  bool currencyCoefficient(Uint32& value) const
3852  {
3854 
3855  return ordinary(value, offset, NullUint32());
3856  }
3857 
3858  /// Provides access to tradingCurrencyIndicator field.
3860  bool
3862  TradingCurrencyIndicator::Enum& value) const
3864  {
3866 
3867  return enumeration<TradingCurrencyIndicator>(value, offset, NullUInt8());
3868  }
3869 
3870  /// Provides access to strikeCurrencyIndicator field.
3872  bool
3874  StrikeCurrencyIndicator::Enum& value) const
3876  {
3878 
3879  return enumeration<StrikeCurrencyIndicator>(value, offset, NullUInt8());
3880  }
3881 
3882  /// Provides access to numberInstrumentCirculating field.
3886  {
3888 
3889  return ordinary(value, offset, NullUint64());
3890  }
3891 
3892  /// Provides access to parValue field.
3894  bool parValue(Uint64& value) const
3896  {
3898 
3899  return ordinary(value, offset, NullUint64());
3900  }
3901 
3902  /// Provides access to quantityNotation field.
3904  bool quantityNotation(StrRef& value) const
3906  {
3909 
3910  return fixedStr<length>(value, offset);
3911  }
3912 
3913  /// Provides access to instUnitExp field.
3915  bool
3917  InstrumentUnitExpression::Enum& value) const
3919  {
3921 
3922  return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
3923  }
3924 
3925  /// Provides access to settlementDelay field.
3927  bool settlementDelay(StrRef& value) const
3929  {
3932 
3933  return fixedStr<length>(value, offset);
3934  }
3935 
3936  /// Provides access to strikeCurrency field.
3938  bool strikeCurrency(StrRef& value) const
3940  {
3943 
3944  return fixedStr<length>(value, offset);
3945  }
3946 
3947  /// Provides access to taxCode field.
3949  bool taxCode(TaxCode::Enum& value) const
3951  {
3953 
3954  return enumeration<TaxCode>(value, offset, NullUInt8());
3955  }
3956 
3957  /// Provides access to typeOfCorporateEvent field.
3959  bool typeOfCorporateEvent(StrRef& value) const
3961  {
3964 
3965  return fixedStr<length>(value, offset);
3966  }
3967 
3968  /// Provides access to typeOfMarketAdmission field.
3970  bool
3972  TypeOfMarketAdmission::Enum& value) const
3974  {
3976 
3977  return enumeration<TypeOfMarketAdmission>(value, offset, NullChar());
3978  }
3979 
3980  /// Provides access to repoIndicator field.
3982  bool
3984  RepoIndicator::Enum& value) const
3986  {
3988 
3989  return enumeration<RepoIndicator>(value, offset, NullUInt8());
3990  }
3991 
3992  /// Provides access to issuePrice field.
3994  bool issuePrice(Int64& value) const
3996  {
3998 
3999  return ordinary(value, offset, NullInt64());
4000  }
4001 
4002  /// Provides access to nominalCurrency field.
4004  bool nominalCurrency(StrRef& value) const
4006  {
4009 
4010  return fixedStr<length>(value, offset);
4011  }
4012 
4013  /// Provides access to issuePriceDecimals field.
4017  {
4019 
4020  return ordinary(value, offset, NullUnsignedChar());
4021  }
4022 
4023  /// Provides access to strikePriceDecimals field.
4027  {
4029 
4030  return ordinary(value, offset, NullUnsignedChar());
4031  }
4032 
4033  /// Provides access to liquidInstrumentIndicator field.
4037  {
4039 
4040  return ordinary(value, offset, NullUnsignedChar());
4041  }
4042 
4043  /// Provides access to marketOfReferenceMIC field.
4045  bool marketOfReferenceMIC(StrRef& value) const
4047  {
4050 
4051  return fixedStr<length>(value, offset);
4052  }
4053 
4054  /// Provides access to iCBCode field.
4056  bool iCBCode(StrRef& value) const
4058  {
4061 
4062  return fixedStr<length>(value, offset);
4063  }
4064 
4065  /// Provides access to thresholdLISPostTrade60mn field.
4069  {
4071 
4072  return ordinary(value, offset, NullUint64());
4073  }
4074 
4075  /// Provides access to thresholdLISPostTrade120mn field.
4079  {
4081 
4082  return ordinary(value, offset, NullUint64());
4083  }
4084 
4085  /// Provides access to thresholdLISPostTradeEOD field.
4089  {
4091 
4092  return ordinary(value, offset, NullUint64());
4093  }
4094 
4095  /// Provides access to longMnemonic field.
4097  bool longMnemonic(StrRef& value) const
4099  {
4103 
4104  return fixedStr<length>(value, offset, since);
4105  }
4106 
4107  /// Provides access to maxOrderAmountCall field.
4109  bool maxOrderAmountCall(Uint64& value) const
4111  {
4114 
4115  return ordinary(value, offset, NullUint64(), since);
4116  }
4117 
4118  /// Provides access to maxOrderAmountContinuous field.
4122  {
4125 
4126  return ordinary(value, offset, NullUint64(), since);
4127  }
4128 
4129  /// Provides access to maxOrderQuantityCall field.
4131  bool maxOrderQuantityCall(Uint64& value) const
4133  {
4136 
4137  return ordinary(value, offset, NullUint64(), since);
4138  }
4139 
4140  /// Provides access to maxOrderQuantityContinuous field.
4144  {
4147 
4148  return ordinary(value, offset, NullUint64(), since);
4149  }
4150 
4151  /// Provides access to poolFactor field.
4153  bool poolFactor(Uint32& value) const
4155  {
4158 
4159  return ordinary(value, offset, NullUint32(), since);
4160  }
4161 
4162  /// \return instance of EmmPatternRep repeating group.
4166  {
4167  return getGroup<EmmPatternRep>(
4168  EmmPatternRepAccess(),
4169  *this);
4170  }
4171 
4172  /// Minimal size of message body in bytes.
4177  {
4178  return
4179  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4180  (version >= 318)
4181  ? 451
4182  : (version >= 316)
4183  ? 415
4184  : 409;
4185  }
4186 
4187  /// Size of message body in bytes.
4192  {
4193  return
4194  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4195  minimalBlockLength(version);
4196  }
4197 
4198  /// Minimal variable fields size (when variable-length fields are empty).
4202  static
4203  MessageSize
4206  {
4207  return
4208  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4209  static_cast<MessageSize>(EmmPatternRep::EmptySize);
4210  }
4211 
4212  /// \return class name.
4216  static const Char* className()
4217  {
4218  return "StandingData";
4219  }
4220 
4221  /// FIX message type.
4225  static StrRef fixType()
4227  {
4228  return constructStrRef("StandingData");
4229  }
4230 
4231  /// \return a human-readable presentation.
4233  std::string toString() const;
4234 
4235 private:
4236  void checkLength(
4237  EncodedLength length, SchemaVersion version) const
4238  {
4239  const EncodedLength minimalRequiredLength =
4240  minimalBlockLength(version) +
4241  MessageHeader::Size +
4242  getMinimalVariableFieldsSize(version);
4243 
4244  checkBinaryLength(
4245  *this, length, minimalRequiredLength);
4246  }
4247 
4248  /// Checks variable fields consistency.
4249  void checkVarLenFields() const
4250  {
4251  groups().
4252  checkTail<EmmPatternRep>();
4253  }
4254 
4255  void checkCompatibility() const
4256  {
4257  assert(TemplateId == templateId());
4258 
4259  checkSchema<Schema>(schemaId(), version());
4260  checkLength(bufferSize(), version());
4261  checkVarLenFields();
4262  }
4263 
4264  /// Access helper.
4265  struct EmmPatternRepAccess
4266  {
4267  EmmPatternRep operator()(const StandingData& obj) const
4269  {
4270  return obj.
4271  groups().
4272  head<EmmPatternRep>();
4273  }
4274  };
4275 };
4276 
4277 /// Message identifiers and length of message root.
4280 : SbeMessage
4281 {
4282  /// Used template schema.
4284 
4285  /// Message template ID from SBE schema.
4286  enum { TemplateId = 1008 };
4287 
4288  /// Initializes a blank instance.
4290 
4291  /// Creates an instance over the given memory block.
4293  const void* data,
4294  EncodedLength length)
4295  : SbeMessage(data, length)
4296  {
4297  checkCompatibility();
4298  }
4299 
4300  /// Creates an instance over the given SBE message.
4301  explicit
4303  const SbeMessage& message)
4304  : SbeMessage(message)
4305  {
4306  assert(message.valid());
4307 
4308  checkCompatibility();
4309  }
4310 
4311  /// Provides access to mDSeqNum field.
4313  bool seqNum(Uint64& value) const
4315  {
4317 
4318  return ordinary(value, offset, NullUint64());
4319  }
4320 
4321  /// Provides access to rebroadcastIndicator field.
4325  {
4327 
4328  return ordinary(value, offset, NullUnsignedChar());
4329  }
4330 
4331  /// Provides access to eMM field.
4333  Emm::Enum eMM() const
4335  {
4337 
4338  return enumeration<Emm>(offset);
4339  }
4340 
4341  /// Provides access to eventTime field.
4343  bool eventTime(Uint64& value) const
4345  {
4347 
4348  return ordinary(value, offset, NullUint64());
4349  }
4350 
4351  /// Provides access to symbolIndex field.
4353  bool symbolIndex(Uint32& value) const
4355  {
4357 
4358  return ordinary(value, offset, NullUint32());
4359  }
4360 
4361  /// Provides access to indexLevel field.
4363  bool indexLevel(Int64& value) const
4365  {
4367 
4368  return ordinary(value, offset, NullInt64());
4369  }
4370 
4371  /// Provides access to pctgOfCapitalization field.
4373  bool pctgOfCapitalization(Uint64& value) const
4375  {
4377 
4378  return ordinary(value, offset, NullUint64());
4379  }
4380 
4381  /// Provides access to prctVarfromPrevClose field.
4383  bool prctVarfromPrevClose(Int64& value) const
4385  {
4387 
4388  return ordinary(value, offset, NullInt64());
4389  }
4390 
4391  /// Provides access to numTradedInstruments field.
4393  bool numTradedInstruments(Uint16& value) const
4395  {
4397 
4398  return ordinary(value, offset, NullUint16());
4399  }
4400 
4401  /// Provides access to indexLevelType field.
4405  {
4407 
4408  return enumeration<IndexLevelType>(offset);
4409  }
4410 
4411  /// Provides access to indexPriceCode field.
4415  {
4417 
4418  return enumeration<IndexPriceCode>(offset);
4419  }
4420 
4421  /// Minimal size of message body in bytes.
4424  static
4425  BlockLength
4429  {
4430  return
4431  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4432  50;
4433  }
4434 
4435  /// Size of message body in bytes.
4440  {
4441  return
4442  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4443  minimalBlockLength(version);
4444  }
4445 
4446  /// Minimal variable fields size (when variable-length fields are empty).
4450  static
4451  MessageSize
4454  {
4455  return
4456  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4457  0;
4458  }
4459 
4460  /// \return class name.
4464  static const Char* className()
4465  {
4466  return "RealTimeIndex";
4467  }
4468 
4469  /// FIX message type.
4473  static StrRef fixType()
4475  {
4476  return constructStrRef("RealTimeIndex");
4477  }
4478 
4479  /// \return a human-readable presentation.
4481  std::string toString() const;
4482 
4483 private:
4484  void checkLength(
4485  EncodedLength length, SchemaVersion version) const
4486  {
4487  const EncodedLength minimalRequiredLength =
4488  minimalBlockLength(version) +
4489  MessageHeader::Size +
4490  getMinimalVariableFieldsSize(version);
4491 
4492  checkBinaryLength(
4493  *this, length, minimalRequiredLength);
4494  }
4495 
4496  void checkCompatibility() const
4497  {
4498  assert(TemplateId == templateId());
4499 
4500  checkSchema<Schema>(schemaId(), version());
4501  checkLength(bufferSize(), version());
4502  }
4503 };
4504 
4505 /// Message identifiers and length of message root.
4507 Statistics
4508 : SbeMessage
4509 {
4510  /// Used template schema.
4512 
4513  /// Message template ID from SBE schema.
4514  enum { TemplateId = 1009 };
4515 
4516  /// Repeating group dimensions.
4517  /// Entry of NewStatsEntry repeating group.
4520  <
4522  >
4523  {
4524  /// Base class type.
4525  typedef
4527  <
4529  >
4531 
4532  /// Initializes instance of given
4533  /// version over given memory block.
4535  const void* data,
4536  EncodedLength length,
4537  SchemaVersion version)
4538  : Base(data, numericCast<Base::BlockLength>(length), version)
4539  {
4540  assert(version >= Schema::MinimalVersion);
4541  assert(length >= minimalBlockLength(version));
4542  }
4543 
4544  /// Provides access to statsUpdateType field.
4548  {
4550 
4551  return enumeration<StatsUpdateType>(offset);
4552  }
4553 
4554  /// Provides access to statsUpdateValue field.
4556  bool statsUpdateValue(Int64& value) const
4558  {
4560 
4561  return ordinary(value, offset, NullInt64());
4562  }
4563 
4564  /// \return size of entry body in bytes
4565  /// for given version of message template.
4570  {
4571  return
4572  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4573  minimalBlockLength(version);
4574  }
4575 
4576  /// \return minimal size of entry body in bytes
4577  /// for given version of message template.
4580  static
4581  BlockLength
4585  {
4586  return
4587  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4588  9;
4589  }
4590 
4591  /// Entity class name.
4595  static const Char* className()
4596  {
4597  return "Statistics.NewStatsEntry";
4598  }
4599  };
4600 
4601  /// Repeating group containing NewStatsEntry entries.
4602  typedef
4605 
4606  /// Initializes a blank instance.
4608 
4609  /// Creates an instance over the given memory block.
4611  const void* data,
4612  EncodedLength length)
4613  : SbeMessage(data, length)
4614  {
4615  checkCompatibility();
4616  }
4617 
4618  /// Creates an instance over the given SBE message.
4619  explicit
4621  const SbeMessage& message)
4622  : SbeMessage(message)
4623  {
4624  assert(message.valid());
4625 
4626  checkCompatibility();
4627  }
4628 
4629  /// Provides access to mDSeqNum field.
4631  bool seqNum(Uint64& value) const
4633  {
4635 
4636  return ordinary(value, offset, NullUint64());
4637  }
4638 
4639  /// Provides access to rebroadcastIndicator field.
4643  {
4645 
4646  return ordinary(value, offset, NullUnsignedChar());
4647  }
4648 
4649  /// Provides access to symbolIndex field.
4651  bool symbolIndex(Uint32& value) const
4653  {
4655 
4656  return ordinary(value, offset, NullUint32());
4657  }
4658 
4659  /// \return instance of NewStats repeating group.
4663  {
4664  return getGroup<NewStats>(NewStatsAccess(), *this);
4665  }
4666 
4667  /// Minimal size of message body in bytes.
4670  static
4671  BlockLength
4675  {
4676  return
4677  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4678  13;
4679  }
4680 
4681  /// Size of message body in bytes.
4686  {
4687  return
4688  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4689  minimalBlockLength(version);
4690  }
4691 
4692  /// Minimal variable fields size (when variable-length fields are empty).
4696  static
4697  MessageSize
4700  {
4701  return
4702  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4703  static_cast<MessageSize>(NewStats::EmptySize);
4704  }
4705 
4706  /// \return class name.
4710  static const Char* className()
4711  {
4712  return "Statistics";
4713  }
4714 
4715  /// FIX message type.
4719  static StrRef fixType()
4721  {
4722  return constructStrRef("Statistics");
4723  }
4724 
4725  /// \return a human-readable presentation.
4727  std::string toString() const;
4728 
4729 private:
4730  void checkLength(
4731  EncodedLength length, SchemaVersion version) const
4732  {
4733  const EncodedLength minimalRequiredLength =
4734  minimalBlockLength(version) +
4735  MessageHeader::Size +
4736  getMinimalVariableFieldsSize(version);
4737 
4738  checkBinaryLength(
4739  *this, length, minimalRequiredLength);
4740  }
4741 
4742  /// Checks variable fields consistency.
4743  void checkVarLenFields() const
4744  {
4745  groups().
4746  checkTail<NewStats>();
4747  }
4748 
4749  void checkCompatibility() const
4750  {
4751  assert(TemplateId == templateId());
4752 
4753  checkSchema<Schema>(schemaId(), version());
4754  checkLength(bufferSize(), version());
4755  checkVarLenFields();
4756  }
4757 
4758  /// Access helper.
4759  struct NewStatsAccess
4760  {
4761  NewStats operator()(const Statistics& obj) const
4763  {
4764  return obj.
4765  groups().
4766  head<NewStats>();
4767  }
4768  };
4769 };
4770 
4771 /// Message identifiers and length of message root.
4774 : SbeMessage
4775 {
4776  /// Used template schema.
4778 
4779  /// Message template ID from SBE schema.
4780  enum { TemplateId = 1011 };
4781 
4782  /// Initializes a blank instance.
4784 
4785  /// Creates an instance over the given memory block.
4787  const void* data,
4788  EncodedLength length)
4789  : SbeMessage(data, length)
4790  {
4791  checkCompatibility();
4792  }
4793 
4794  /// Creates an instance over the given SBE message.
4795  explicit
4797  const SbeMessage& message)
4798  : SbeMessage(message)
4799  {
4800  assert(message.valid());
4801 
4802  checkCompatibility();
4803  }
4804 
4805  /// Provides access to mDSeqNum field.
4807  bool seqNum(Uint64& value) const
4809  {
4811 
4812  return ordinary(value, offset, NullUint64());
4813  }
4814 
4815  /// Provides access to rebroadcastIndicator field.
4819  {
4821 
4822  return ordinary(value, offset, NullUnsignedChar());
4823  }
4824 
4825  /// Provides access to eMM field.
4827  Emm::Enum eMM() const
4829  {
4831 
4832  return enumeration<Emm>(offset);
4833  }
4834 
4835  /// Provides access to eventTime field.
4837  bool eventTime(Uint64& value) const
4839  {
4841 
4842  return ordinary(value, offset, NullUint64());
4843  }
4844 
4845  /// Provides access to symbolIndex field.
4847  bool symbolIndex(Uint32& value) const
4849  {
4851 
4852  return ordinary(value, offset, NullUint32());
4853  }
4854 
4855  /// Provides access to openingLevel field.
4857  bool openingLevel(Int64& value) const
4859  {
4861 
4862  return ordinary(value, offset, NullInt64());
4863  }
4864 
4865  /// Provides access to openingTime field.
4867  bool openingTime(Uint64& value) const
4869  {
4871 
4872  return ordinary(value, offset, NullUint64());
4873  }
4874 
4875  /// Provides access to confirmedReferenceLevel field.
4877  bool confirmedReferenceLevel(Int64& value) const
4879  {
4881 
4882  return ordinary(value, offset, NullInt64());
4883  }
4884 
4885  /// Provides access to confirmedReferenceTime field.
4887  bool confirmedReferenceTime(Uint64& value) const
4889  {
4891 
4892  return ordinary(value, offset, NullUint64());
4893  }
4894 
4895  /// Provides access to closingReferenceLevel field.
4897  bool closingReferenceLevel(Int64& value) const
4899  {
4901 
4902  return ordinary(value, offset, NullInt64());
4903  }
4904 
4905  /// Provides access to closingReferenceTime field.
4907  bool closingReferenceTime(Uint64& value) const
4909  {
4911 
4912  return ordinary(value, offset, NullUint64());
4913  }
4914 
4915  /// Provides access to prctVarfromPrevClose field.
4917  bool prctVarfromPrevClose(Int64& value) const
4919  {
4921 
4922  return ordinary(value, offset, NullInt64());
4923  }
4924 
4925  /// Provides access to highLevel field.
4927  bool highLevel(Int64& value) const
4929  {
4931 
4932  return ordinary(value, offset, NullInt64());
4933  }
4934 
4935  /// Provides access to highTime field.
4937  bool highTime(Uint64& value) const
4939  {
4941 
4942  return ordinary(value, offset, NullUint64());
4943  }
4944 
4945  /// Provides access to lowLevel field.
4947  bool lowLevel(Int64& value) const
4949  {
4951 
4952  return ordinary(value, offset, NullInt64());
4953  }
4954 
4955  /// Provides access to lowTime field.
4957  bool lowTime(Uint64& value) const
4959  {
4961 
4962  return ordinary(value, offset, NullUint64());
4963  }
4964 
4965  /// Provides access to liquidationLevel field.
4967  bool liquidationLevel(Int64& value) const
4969  {
4971 
4972  return ordinary(value, offset, NullInt64());
4973  }
4974 
4975  /// Provides access to liquidationTime field.
4977  bool liquidationTime(Uint64& value) const
4979  {
4981 
4982  return ordinary(value, offset, NullUint64());
4983  }
4984 
4985  /// Minimal size of message body in bytes.
4988  static
4989  BlockLength
4993  {
4994  return
4995  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4996  126;
4997  }
4998 
4999  /// Size of message body in bytes.
5004  {
5005  return
5006  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5007  minimalBlockLength(version);
5008  }
5009 
5010  /// Minimal variable fields size (when variable-length fields are empty).
5014  static
5015  MessageSize
5018  {
5019  return
5020  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5021  0;
5022  }
5023 
5024  /// \return class name.
5028  static const Char* className()
5029  {
5030  return "IndexSummary";
5031  }
5032 
5033  /// FIX message type.
5037  static StrRef fixType()
5039  {
5040  return constructStrRef("IndexSummary");
5041  }
5042 
5043  /// \return a human-readable presentation.
5045  std::string toString() const;
5046 
5047 private:
5048  void checkLength(
5049  EncodedLength length, SchemaVersion version) const
5050  {
5051  const EncodedLength minimalRequiredLength =
5052  minimalBlockLength(version) +
5053  MessageHeader::Size +
5054  getMinimalVariableFieldsSize(version);
5055 
5056  checkBinaryLength(
5057  *this, length, minimalRequiredLength);
5058  }
5059 
5060  void checkCompatibility() const
5061  {
5062  assert(TemplateId == templateId());
5063 
5064  checkSchema<Schema>(schemaId(), version());
5065  checkLength(bufferSize(), version());
5066  }
5067 };
5068 
5069 /// Message identifiers and length of message root.
5072 : SbeMessage
5073 {
5074  /// Used template schema.
5076 
5077  /// Message template ID from SBE schema.
5078  enum { TemplateId = 1012 };
5079 
5080  /// Repeating group dimensions.
5081  /// Entry of StrategyStandingDatarep1Entry repeating group.
5084  <
5086  >
5087  {
5088  /// Base class type.
5089  typedef
5091  <
5093  >
5095 
5096  /// Initializes instance of given
5097  /// version over given memory block.
5099  const void* data,
5100  EncodedLength length,
5101  SchemaVersion version)
5102  : Base(data, numericCast<Base::BlockLength>(length), version)
5103  {
5104  assert(version >= Schema::MinimalVersion);
5105  assert(length >= minimalBlockLength(version));
5106  }
5107 
5108  /// Provides access to legSymbolIndex field.
5110  bool legSymbolIndex(Uint32& value) const
5112  {
5114 
5115  return ordinary(value, offset, NullUint32());
5116  }
5117 
5118  /// Provides access to legPrice field.
5120  bool legPrice(Int64& value) const
5122  {
5124 
5125  return ordinary(value, offset, NullInt64());
5126  }
5127 
5128  /// Provides access to legRatio field.
5130  bool legRatio(Uint32& value) const
5132  {
5134 
5135  return ordinary(value, offset, NullUint32());
5136  }
5137 
5138  /// Provides access to legBuySell field.
5142  {
5144 
5145  return enumeration<LegBuyorSell>(offset);
5146  }
5147 
5148  /// \return size of entry body in bytes
5149  /// for given version of message template.
5154  {
5155  return
5156  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5157  minimalBlockLength(version);
5158  }
5159 
5160  /// \return minimal size of entry body in bytes
5161  /// for given version of message template.
5164  static
5165  BlockLength
5169  {
5170  return
5171  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5172  17;
5173  }
5174 
5175  /// Entity class name.
5179  static const Char* className()
5180  {
5181  return "StrategyStandingData.StrategyStandingDatarep1Entry";
5182  }
5183  };
5184 
5185  /// Repeating group containing StrategyStandingDatarep1Entry entries.
5186  typedef
5189 
5190  /// Initializes a blank instance.
5192 
5193  /// Creates an instance over the given memory block.
5195  const void* data,
5196  EncodedLength length)
5197  : SbeMessage(data, length)
5198  {
5199  checkCompatibility();
5200  }
5201 
5202  /// Creates an instance over the given SBE message.
5203  explicit
5205  const SbeMessage& message)
5206  : SbeMessage(message)
5207  {
5208  assert(message.valid());
5209 
5210  checkCompatibility();
5211  }
5212 
5213  /// Provides access to mDSeqNum field.
5215  bool seqNum(Uint64& value) const
5217  {
5219 
5220  return ordinary(value, offset, NullUint64());
5221  }
5222 
5223  /// Provides access to rebroadcastIndicator field.
5227  {
5229 
5230  return ordinary(value, offset, NullUnsignedChar());
5231  }
5232 
5233  /// Provides access to eMM field.
5235  Emm::Enum eMM() const
5237  {
5239 
5240  return enumeration<Emm>(offset);
5241  }
5242 
5243  /// Provides access to symbolIndex field.
5245  bool symbolIndex(Uint32& value) const
5247  {
5249 
5250  return ordinary(value, offset, NullUint32());
5251  }
5252 
5253  /// Provides access to derivativesInstrumentTradingCode field.
5257  {
5260 
5261  return fixedStr<length>(offset);
5262  }
5263 
5264  /// Provides access to exchangeCode field.
5268  {
5270 
5271  return enumeration<ExchangeCode>(offset);
5272  }
5273 
5274  /// Provides access to maturityDate field.
5278  {
5281 
5282  return fixedStr<length>(offset);
5283  }
5284 
5285  /// Provides access to strategyCode field.
5289  {
5291 
5292  return enumeration<StrategyCode>(offset);
5293  }
5294 
5295  /// Provides access to contractSymbolIndex field.
5297  bool contractSymbolIndex(Uint32& value) const
5299  {
5301 
5302  return ordinary(value, offset, NullUint32());
5303  }
5304 
5305  /// Provides access to cFI field.
5307  bool cFI(StrRef& value) const
5309  {
5312 
5313  return fixedStr<length>(value, offset);
5314  }
5315 
5316  /// \return instance of StrategyStandingDatarep1 repeating group.
5320  {
5321  return getGroup<StrategyStandingDatarep1>(
5322  StrategyStandingDatarep1Access(),
5323  *this);
5324  }
5325 
5326  /// Minimal size of message body in bytes.
5329  static
5330  BlockLength
5334  {
5335  return
5336  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5337  52;
5338  }
5339 
5340  /// Size of message body in bytes.
5345  {
5346  return
5347  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5348  minimalBlockLength(version);
5349  }
5350 
5351  /// Minimal variable fields size (when variable-length fields are empty).
5355  static
5356  MessageSize
5359  {
5360  return
5361  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5362  static_cast<MessageSize>(StrategyStandingDatarep1::EmptySize);
5363  }
5364 
5365  /// \return class name.
5369  static const Char* className()
5370  {
5371  return "StrategyStandingData";
5372  }
5373 
5374  /// FIX message type.
5378  static StrRef fixType()
5380  {
5381  return constructStrRef("StrategyStandingData");
5382  }
5383 
5384  /// \return a human-readable presentation.
5386  std::string toString() const;
5387 
5388 private:
5389  void checkLength(
5390  EncodedLength length, SchemaVersion version) const
5391  {
5392  const EncodedLength minimalRequiredLength =
5393  minimalBlockLength(version) +
5394  MessageHeader::Size +
5395  getMinimalVariableFieldsSize(version);
5396 
5397  checkBinaryLength(
5398  *this, length, minimalRequiredLength);
5399  }
5400 
5401  /// Checks variable fields consistency.
5402  void checkVarLenFields() const
5403  {
5404  groups().
5405  checkTail<StrategyStandingDatarep1>();
5406  }
5407 
5408  void checkCompatibility() const
5409  {
5410  assert(TemplateId == templateId());
5411 
5412  checkSchema<Schema>(schemaId(), version());
5413  checkLength(bufferSize(), version());
5414  checkVarLenFields();
5415  }
5416 
5417  /// Access helper.
5418  struct StrategyStandingDatarep1Access
5419  {
5421  operator()(
5422  const StrategyStandingData& obj) const
5424  {
5425  return obj.
5426  groups().
5427  head<StrategyStandingDatarep1>();
5428  }
5429  };
5430 };
5431 
5432 /// Message identifiers and length of message root.
5435 : SbeMessage
5436 {
5437  /// Used template schema.
5439 
5440  /// Message template ID from SBE schema.
5441  enum { TemplateId = 1013 };
5442 
5443  /// Repeating group dimensions.
5444  /// Entry of ContractEMMPropertiesEntry repeating group.
5447  <
5449  >
5450  {
5451  /// Base class type.
5452  typedef
5454  <
5456  >
5458 
5459  /// Initializes instance of given
5460  /// version over given memory block.
5462  const void* data,
5463  EncodedLength length,
5464  SchemaVersion version)
5465  : Base(data, numericCast<Base::BlockLength>(length), version)
5466  {
5467  assert(version >= Schema::MinimalVersion);
5468  assert(length >= minimalBlockLength(version));
5469  }
5470 
5471  /// Provides access to eMM field.
5473  bool eMM(Emm::Enum& value) const
5475  {
5477 
5478  return enumeration<Emm>(value, offset, NullUInt8());
5479  }
5480 
5481  /// Provides access to tickSizeIndexID field.
5483  bool tickSizeIndexId(Uint16& value) const
5485  {
5487 
5488  return ordinary(value, offset, NullUint16());
5489  }
5490 
5491  /// Provides access to patternID field.
5493  bool patternId(Uint16& value) const
5495  {
5497 
5498  return ordinary(value, offset, NullUint16());
5499  }
5500 
5501  /// Provides access to lotSize field.
5503  bool lotSize(Uint64& value) const
5505  {
5507 
5508  return ordinary(value, offset, NullUint64());
5509  }
5510 
5511  /// Provides access to strategyAuthorized field.
5513  bool
5515  StrategyAuthorized& value) const
5517  {
5519 
5520  return ordinary(value, offset, NullUInt64());
5521  }
5522 
5523  /// Provides access to dynamicCollarLogic field.
5525  bool
5527  DynamicCollarLogic::Enum& value) const
5529  {
5531 
5532  return enumeration<DynamicCollarLogic>(value, offset, NullUInt8());
5533  }
5534 
5535  /// Provides access to collarMaxUnhaltNb field.
5537  bool collarMaxUnhaltNb(UnsignedChar& value) const
5539  {
5541 
5542  return ordinary(value, offset, NullUnsignedChar());
5543  }
5544 
5545  /// Provides access to collarUnhaltDelay field.
5547  bool collarUnhaltDelay(Uint32& value) const
5549  {
5551 
5552  return ordinary(value, offset, NullUint32());
5553  }
5554 
5555  /// \return size of entry body in bytes
5556  /// for given version of message template.
5561  {
5562  return
5563  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5564  minimalBlockLength(version);
5565  }
5566 
5567  /// \return minimal size of entry body in bytes
5568  /// for given version of message template.
5571  static
5572  BlockLength
5576  {
5577  return
5578  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5579  27;
5580  }
5581 
5582  /// Entity class name.
5586  static const Char* className()
5587  {
5588  return "ContractStandingData.ContractEMMPropertiesEntry";
5589  }
5590  };
5591 
5592  /// Repeating group containing ContractEMMPropertiesEntry entries.
5593  typedef
5596 
5597  /// Initializes a blank instance.
5599 
5600  /// Creates an instance over the given memory block.
5602  const void* data,
5603  EncodedLength length)
5604  : SbeMessage(data, length)
5605  {
5606  checkCompatibility();
5607  }
5608 
5609  /// Creates an instance over the given SBE message.
5610  explicit
5612  const SbeMessage& message)
5613  : SbeMessage(message)
5614  {
5615  assert(message.valid());
5616 
5617  checkCompatibility();
5618  }
5619 
5620  /// Provides access to mDSeqNum field.
5622  bool seqNum(Uint64& value) const
5624  {
5626 
5627  return ordinary(value, offset, NullUint64());
5628  }
5629 
5630  /// Provides access to rebroadcastIndicator field.
5634  {
5636 
5637  return ordinary(value, offset, NullUnsignedChar());
5638  }
5639 
5640  /// Provides access to symbolIndex field.
5642  bool symbolIndex(Uint32& value) const
5644  {
5646 
5647  return ordinary(value, offset, NullUint32());
5648  }
5649 
5650  /// Provides access to optiqSegment field.
5654  {
5656 
5657  return enumeration<OptiqSegment>(offset);
5658  }
5659 
5660  /// Provides access to partitionID field.
5662  bool partitionId(Uint16& value) const
5664  {
5666 
5667  return ordinary(value, offset, NullUint16());
5668  }
5669 
5670  /// Provides access to contractEventDate field.
5672  bool contractEventDate(Uint16& value) const
5674  {
5676 
5677  return ordinary(value, offset, NullUint16());
5678  }
5679 
5680  /// Provides access to exchangeCode field.
5684  {
5686 
5687  return enumeration<ExchangeCode>(offset);
5688  }
5689 
5690  /// Provides access to exerStyle field.
5692  bool
5694  ExerciseStyle::Enum& value) const
5696  {
5698 
5699  return enumeration<ExerciseStyle>(value, offset, NullUInt8());
5700  }
5701 
5702  /// Provides access to contractName field.
5706  {
5709 
5710  return fixedStr<length>(offset);
5711  }
5712 
5713  /// Provides access to contractType field.
5715  bool
5717  ContractType::Enum& value) const
5719  {
5721 
5722  return enumeration<ContractType>(value, offset, NullChar());
5723  }
5724 
5725  /// Provides access to underlyingType field.
5729  {
5731 
5732  return enumeration<UnderlyingType>(offset);
5733  }
5734 
5735  /// Provides access to priceDecimals field.
5737  bool priceDecimals(UnsignedChar& value) const
5739  {
5741 
5742  return ordinary(value, offset, NullUnsignedChar());
5743  }
5744 
5745  /// Provides access to quantityDecimals field.
5747  bool quantityDecimals(UnsignedChar& value) const
5749  {
5751 
5752  return ordinary(value, offset, NullUnsignedChar());
5753  }
5754 
5755  /// Provides access to amountDecimals field.
5757  bool amountDecimals(UnsignedChar& value) const
5759  {
5761 
5762  return ordinary(value, offset, NullUnsignedChar());
5763  }
5764 
5765  /// Provides access to ratioDecimals field.
5767  bool ratioDecimals(UnsignedChar& value) const
5769  {
5771 
5772  return ordinary(value, offset, NullUnsignedChar());
5773  }
5774 
5775  /// Provides access to mainDepositary field.
5777  bool mainDepositary(StrRef& value) const
5779  {
5782 
5783  return fixedStr<length>(value, offset);
5784  }
5785 
5786  /// Provides access to mIC field.
5788  StrRef mIC() const
5790  {
5793 
5794  return fixedStr<length>(offset);
5795  }
5796 
5797  /// Provides access to countryOfExchange field.
5801  {
5804 
5805  return fixedStr<length>(offset);
5806  }
5807 
5808  /// Provides access to productCode field.
5812  {
5815 
5816  return fixedStr<length>(offset);
5817  }
5818 
5819  /// Provides access to underlyingMIC field.
5821  bool underlyingMIC(StrRef& value) const
5823  {
5826 
5827  return fixedStr<length>(value, offset);
5828  }
5829 
5830  /// Provides access to underlyingISINCode field.
5832  bool underlyingISINCode(StrRef& value) const
5834  {
5837 
5838  return fixedStr<length>(value, offset);
5839  }
5840 
5841  /// Provides access to underlyingExpiry field.
5843  bool underlyingExpiry(Uint32& value) const
5845  {
5847 
5848  return ordinary(value, offset, NullUint32());
5849  }
5850 
5851  /// Provides access to orderTypeRules field.
5855  {
5857 
5858  return ordinary<OrderTypeRules>(offset);
5859  }
5860 
5861  /// Provides access to settlementMethod field.
5863  bool settlementMethod(Char& value) const
5865  {
5867 
5868  return ordinary(value, offset, NullChar());
5869  }
5870 
5871  /// Provides access to tradingCurrency field.
5875  {
5878 
5879  return fixedStr<length>(offset);
5880  }
5881 
5882  /// Provides access to strikePriceDecimalsRatio field.
5886  {
5888 
5889  return ordinary(value, offset, NullUnsignedChar());
5890  }
5891 
5892  /// Provides access to mMProtections field.
5896  {
5898 
5899  return ordinary<MmProtections>(offset);
5900  }
5901 
5902  /// Provides access to contractTradingType field.
5907  {
5909 
5910  return enumeration<ContractTradingType>(offset);
5911  }
5912 
5913  /// Provides access to instUnitExp field.
5915  bool
5917  InstrumentUnitExpression::Enum& value) const
5919  {
5921 
5922  return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
5923  }
5924 
5925  /// Provides access to underlyingSubtype field.
5927  bool
5929  UnderlyingSubtype::Enum& value) const
5931  {
5933 
5934  return enumeration<UnderlyingSubtype>(value, offset, NullUInt8());
5935  }
5936 
5937  /// Provides access to motherStockISIN field.
5939  bool motherStockISIN(StrRef& value) const
5941  {
5944 
5945  return fixedStr<length>(value, offset);
5946  }
5947 
5948  /// Provides access to settlementTickSize field.
5950  bool settlementTickSize(Uint64& value) const
5952  {
5954 
5955  return ordinary(value, offset, NullUint64());
5956  }
5957 
5958  /// Provides access to eDSPTickSize field.
5960  bool eDSPTickSize(Uint64& value) const
5962  {
5964 
5965  return ordinary(value, offset, NullUint64());
5966  }
5967 
5968  /// Provides access to underlyingSymbolIndex field.
5970  bool underlyingSymbolIndex(Uint32& value) const
5972  {
5974 
5975  return ordinary(value, offset, NullUint32());
5976  }
5977 
5978  /// Provides access to tradingPolicy field.
5980  bool
5982  TradingPolicy::Enum& value) const
5984  {
5986 
5987  return enumeration<TradingPolicy>(value, offset, NullUInt8());
5988  }
5989 
5990  /// Provides access to referenceSpreadTableID field.
5992  bool referenceSpreadTableId(Uint16& value) const
5994  {
5996 
5997  return ordinary(value, offset, NullUint16());
5998  }
5999 
6000  /// Provides access to derivativesMarketModel field.
6002  bool
6004  DerivativesMarketModel::Enum& value) const
6006  {
6008 
6009  return enumeration<DerivativesMarketModel>(value, offset, NullUInt8());
6010  }
6011 
6012  /// Provides access to tradingUnit field.
6014  bool tradingUnit(Uint64& value) const
6016  {
6018 
6019  return ordinary(value, offset, NullUint64());
6020  }
6021 
6022  /// Provides access to referencePriceOriginInOpeningCall field.
6024  bool
6026  ReferencePriceOrigin::Enum& value) const
6028  {
6030 
6031  return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6032  }
6033 
6034  /// Provides access to referencePriceOriginInContinuous field.
6036  bool
6038  ReferencePriceOrigin::Enum& value) const
6040  {
6042 
6043  return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6044  }
6045 
6046  /// Provides access to referencePriceOriginInTradingInterruption field.
6048  bool
6050  ReferencePriceOrigin::Enum& value) const
6052  {
6054 
6055  return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6056  }
6057 
6058  /// Provides access to collarExpansionFactor field.
6062  {
6064 
6065  return ordinary(value, offset, NullUnsignedChar());
6066  }
6067 
6068  /// Provides access to mIFIDIILiquidFlag field.
6070  bool mIFIdIILiquidFlag(UnsignedChar& value) const
6072  {
6074 
6075  return ordinary(value, offset, NullUnsignedChar());
6076  }
6077 
6078  /// Provides access to pricingAlgorithm field.
6082  {
6084 
6085  return enumeration<PricingAlgorithm>(offset);
6086  }
6087 
6088  /// Provides access to lotMultiplier field.
6090  bool lotMultiplier(Uint64& value) const
6092  {
6095 
6096  return ordinary(value, offset, NullUint64(), since);
6097  }
6098 
6099  /// \return instance of ContractEMMProperties repeating group.
6103  {
6104  return getGroup<ContractEMMProperties>(
6105  ContractEMMPropertiesAccess(),
6106  *this);
6107  }
6108 
6109  /// Minimal size of message body in bytes.
6114  {
6115  return
6116  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6117  (version >= 327)
6118  ? 191
6119  : 183;
6120  }
6121 
6122  /// Size of message body in bytes.
6127  {
6128  return
6129  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6130  minimalBlockLength(version);
6131  }
6132 
6133  /// Minimal variable fields size (when variable-length fields are empty).
6137  static
6138  MessageSize
6141  {
6142  return
6143  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6144  static_cast<MessageSize>(ContractEMMProperties::EmptySize);
6145  }
6146 
6147  /// \return class name.
6151  static const Char* className()
6152  {
6153  return "ContractStandingData";
6154  }
6155 
6156  /// FIX message type.
6160  static StrRef fixType()
6162  {
6163  return constructStrRef("ContractStandingData");
6164  }
6165 
6166  /// \return a human-readable presentation.
6168  std::string toString() const;
6169 
6170 private:
6171  void checkLength(
6172  EncodedLength length, SchemaVersion version) const
6173  {
6174  const EncodedLength minimalRequiredLength =
6175  minimalBlockLength(version) +
6176  MessageHeader::Size +
6177  getMinimalVariableFieldsSize(version);
6178 
6179  checkBinaryLength(
6180  *this, length, minimalRequiredLength);
6181  }
6182 
6183  /// Checks variable fields consistency.
6184  void checkVarLenFields() const
6185  {
6186  groups().
6187  checkTail<ContractEMMProperties>();
6188  }
6189 
6190  void checkCompatibility() const
6191  {
6192  assert(TemplateId == templateId());
6193 
6194  checkSchema<Schema>(schemaId(), version());
6195  checkLength(bufferSize(), version());
6196  checkVarLenFields();
6197  }
6198 
6199  /// Access helper.
6200  struct ContractEMMPropertiesAccess
6201  {
6203  operator()(
6204  const ContractStandingData& obj) const
6206  {
6207  return obj.
6208  groups().
6209  head<ContractEMMProperties>();
6210  }
6211  };
6212 };
6213 
6214 /// Message identifiers and length of message root.
6217 : SbeMessage
6218 {
6219  /// Used template schema.
6221 
6222  /// Message template ID from SBE schema.
6223  enum { TemplateId = 1014 };
6224 
6225  /// Repeating group dimensions.
6226  /// Entry of OutrightRepEntry repeating group.
6229  <
6231  >
6232  {
6233  /// Base class type.
6234  typedef
6236  <
6238  >
6240 
6241  /// Initializes instance of given
6242  /// version over given memory block.
6244  const void* data,
6245  EncodedLength length,
6246  SchemaVersion version)
6247  : Base(data, numericCast<Base::BlockLength>(length), version)
6248  {
6249  assert(version >= Schema::MinimalVersion);
6250  assert(length >= minimalBlockLength(version));
6251  }
6252 
6253  /// Provides access to eMM field.
6255  Emm::Enum eMM() const
6257  {
6259 
6260  return enumeration<Emm>(offset);
6261  }
6262 
6263  /// \return size of entry body in bytes
6264  /// for given version of message template.
6269  {
6270  return
6271  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6272  minimalBlockLength(version);
6273  }
6274 
6275  /// \return minimal size of entry body in bytes
6276  /// for given version of message template.
6279  static
6280  BlockLength
6284  {
6285  return
6286  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6287  1;
6288  }
6289 
6290  /// Entity class name.
6294  static const Char* className()
6295  {
6296  return "OutrightStandingData.OutrightRepEntry";
6297  }
6298  };
6299 
6300  /// Repeating group containing OutrightRepEntry entries.
6301  typedef
6304 
6305  /// Initializes a blank instance.
6307 
6308  /// Creates an instance over the given memory block.
6310  const void* data,
6311  EncodedLength length)
6312  : SbeMessage(data, length)
6313  {
6314  checkCompatibility();
6315  }
6316 
6317  /// Creates an instance over the given SBE message.
6318  explicit
6320  const SbeMessage& message)
6321  : SbeMessage(message)
6322  {
6323  assert(message.valid());
6324 
6325  checkCompatibility();
6326  }
6327 
6328  /// Provides access to mDSeqNum field.
6330  bool seqNum(Uint64& value) const
6332  {
6334 
6335  return ordinary(value, offset, NullUint64());
6336  }
6337 
6338  /// Provides access to rebroadcastIndicator field.
6342  {
6344 
6345  return ordinary(value, offset, NullUnsignedChar());
6346  }
6347 
6348  /// Provides access to symbolIndex field.
6350  bool symbolIndex(Uint32& value) const
6352  {
6354 
6355  return ordinary(value, offset, NullUint32());
6356  }
6357 
6358  /// Provides access to contractSymbolIndex field.
6360  bool contractSymbolIndex(Uint32& value) const
6362  {
6364 
6365  return ordinary(value, offset, NullUint32());
6366  }
6367 
6368  /// Provides access to instrumentEventDate field.
6370  bool instrumentEventDate(Uint16& value) const
6372  {
6374 
6375  return ordinary(value, offset, NullUint16());
6376  }
6377 
6378  /// Provides access to iSINCode field.
6382  {
6385 
6386  return fixedStr<length>(offset);
6387  }
6388 
6389  /// Provides access to cFI field.
6391  bool cFI(StrRef& value) const
6393  {
6396 
6397  return fixedStr<length>(value, offset);
6398  }
6399 
6400  /// Provides access to maturityDate field.
6404  {
6407 
6408  return fixedStr<length>(offset);
6409  }
6410 
6411  /// Provides access to lotSize field.
6413  bool lotSize(Uint64& value) const
6415  {
6417 
6418  return ordinary(value, offset, NullUint64());
6419  }
6420 
6421  /// Provides access to strikePrice field.
6423  bool strikePrice(Int64& value) const
6425  {
6427 
6428  return ordinary(value, offset, NullInt64());
6429  }
6430 
6431  /// Provides access to lastTradingDate field.
6433  bool lastTradingDate(Uint16& value) const
6435  {
6437 
6438  return ordinary(value, offset, NullUint16());
6439  }
6440 
6441  /// Provides access to daysToExpiry field.
6443  bool daysToExpiry(Uint16& value) const
6445  {
6447 
6448  return ordinary(value, offset, NullUint16());
6449  }
6450 
6451  /// Provides access to derivativesInstrumentTradingCode field.
6455  {
6458 
6459  return fixedStr<length>(value, offset);
6460  }
6461 
6462  /// Provides access to derivativesInstrumentType field.
6464  bool
6466  DerivativesInstrumentType::Enum& value) const
6468  {
6470 
6471  return enumeration<DerivativesInstrumentType>(value, offset, NullUInt8());
6472  }
6473 
6474  /// Provides access to expiryCycleType field.
6476  bool
6478  ExpiryCycleType::Enum& value) const
6480  {
6482 
6483  return enumeration<ExpiryCycleType>(value, offset, NullUInt8());
6484  }
6485 
6486  /// Provides access to underlyingDerivativesInstrumentTradingCode field.
6490  {
6493 
6494  return fixedStr<length>(value, offset);
6495  }
6496 
6497  /// Provides access to underlyingSymbolIndex field.
6499  bool underlyingSymbolIndex(Uint32& value) const
6501  {
6503 
6504  return ordinary(value, offset, NullUint32());
6505  }
6506 
6507  /// Provides access to tradingUnit field.
6509  bool tradingUnit(Uint64& value) const
6511  {
6513 
6514  return ordinary(value, offset, NullUint64());
6515  }
6516 
6517  /// Provides access to lotMultiplier field.
6519  bool lotMultiplier(Uint64& value) const
6521  {
6524 
6525  return ordinary(value, offset, NullUint64(), since);
6526  }
6527 
6528  /// Provides access to expirationDate field.
6530  bool expirationDate(Uint16& value) const
6532  {
6535 
6536  return ordinary(value, offset, NullUint16(), since);
6537  }
6538 
6539  /// \return instance of OutrightRep repeating group.
6543  {
6544  return getGroup<OutrightRep>(
6545  OutrightRepAccess(),
6546  *this);
6547  }
6548 
6549  /// Minimal size of message body in bytes.
6554  {
6555  return
6556  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6557  (version >= 327)
6558  ? 125
6559  : 115;
6560  }
6561 
6562  /// Size of message body in bytes.
6567  {
6568  return
6569  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6570  minimalBlockLength(version);
6571  }
6572 
6573  /// Minimal variable fields size (when variable-length fields are empty).
6577  static
6578  MessageSize
6581  {
6582  return
6583  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6584  static_cast<MessageSize>(OutrightRep::EmptySize);
6585  }
6586 
6587  /// \return class name.
6591  static const Char* className()
6592  {
6593  return "OutrightStandingData";
6594  }
6595 
6596  /// FIX message type.
6600  static StrRef fixType()
6602  {
6603  return constructStrRef("OutrightStandingData");
6604  }
6605 
6606  /// \return a human-readable presentation.
6608  std::string toString() const;
6609 
6610 private:
6611  void checkLength(
6612  EncodedLength length, SchemaVersion version) const
6613  {
6614  const EncodedLength minimalRequiredLength =
6615  minimalBlockLength(version) +
6616  MessageHeader::Size +
6617  getMinimalVariableFieldsSize(version);
6618 
6619  checkBinaryLength(
6620  *this, length, minimalRequiredLength);
6621  }
6622 
6623  /// Checks variable fields consistency.
6624  void checkVarLenFields() const
6625  {
6626  groups().
6627  checkTail<OutrightRep>();
6628  }
6629 
6630  void checkCompatibility() const
6631  {
6632  assert(TemplateId == templateId());
6633 
6634  checkSchema<Schema>(schemaId(), version());
6635  checkLength(bufferSize(), version());
6636  checkVarLenFields();
6637  }
6638 
6639  /// Access helper.
6640  struct OutrightRepAccess
6641  {
6642  OutrightRep
6643  operator()(
6644  const OutrightStandingData& obj) const
6646  {
6647  return obj.
6648  groups().
6649  head<OutrightRep>();
6650  }
6651  };
6652 };
6653 
6654 /// Message identifiers and length of message root.
6657 : SbeMessage
6658 {
6659  /// Used template schema.
6661 
6662  /// Message template ID from SBE schema.
6663  enum { TemplateId = 1015 };
6664 
6665  /// Repeating group dimensions.
6666  /// Entry of OrdersEntry repeating group.
6669  <
6671  >
6672  {
6673  /// Base class type.
6674  typedef
6676  <
6678  >
6680 
6681  /// Initializes instance of given
6682  /// version over given memory block.
6684  const void* data,
6685  EncodedLength length,
6686  SchemaVersion version)
6687  : Base(data, numericCast<Base::BlockLength>(length), version)
6688  {
6689  assert(version >= Schema::MinimalVersion);
6690  assert(length >= minimalBlockLength(version));
6691  }
6692 
6693  /// Provides access to symbolIndex field.
6695  bool symbolIndex(Uint32& value) const
6697  {
6699 
6700  return ordinary(value, offset, NullUint32());
6701  }
6702 
6703  /// Provides access to actionType field.
6706  actionType() const
6708  {
6710 
6711  return enumeration<MarketDataActionType>(offset);
6712  }
6713 
6714  /// Provides access to orderPriority field.
6716  bool orderPriority(Uint64& value) const
6718  {
6720 
6721  return ordinary(value, offset, NullUint64());
6722  }
6723 
6724  /// Provides access to previousPriority field.
6726  bool previousPriority(Uint64& value) const
6728  {
6730 
6731  return ordinary(value, offset, NullUint64());
6732  }
6733 
6734  /// Provides access to orderType field.
6736  bool orderType(OrderType::Enum& value) const
6738  {
6740 
6741  return enumeration<OrderType>(value, offset, NullUInt8());
6742  }
6743 
6744  /// Provides access to orderPx field.
6746  bool orderPx(Int64& value) const
6748  {
6750 
6751  return ordinary(value, offset, NullInt64());
6752  }
6753 
6754  /// Provides access to orderSide field.
6756  bool orderSide(OrderSide::Enum& value) const
6758  {
6760 
6761  return enumeration<OrderSide>(value, offset, NullUInt8());
6762  }
6763 
6764  /// Provides access to orderQuantity field.
6766  bool orderQuantity(Uint64& value) const
6768  {
6770 
6771  return ordinary(value, offset, NullUint64());
6772  }
6773 
6774  /// Provides access to pegOffset field.
6776  bool pegOffset(Int8& value) const
6778  {
6780 
6781  return ordinary(value, offset, NullInt8());
6782  }
6783 
6784  /// Provides access to firmID field.
6786  StrRef firmId() const
6788  {
6791 
6792  return fixedStr<length>(offset);
6793  }
6794 
6795  /// Provides access to accountType field.
6799  {
6801 
6802  return enumeration<AccountType>(offset);
6803  }
6804 
6805  /// \return size of entry body in bytes
6806  /// for given version of message template.
6811  {
6812  return
6813  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6814  minimalBlockLength(version);
6815  }
6816 
6817  /// \return minimal size of entry body in bytes
6818  /// for given version of message template.
6821  static
6822  BlockLength
6826  {
6827  return
6828  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6829  49;
6830  }
6831 
6832  /// Entity class name.
6836  static const Char* className()
6837  {
6838  return "LongOrderUpdate.OrdersEntry";
6839  }
6840  };
6841 
6842  /// Repeating group containing OrdersEntry entries.
6843  typedef
6846 
6847  /// Initializes a blank instance.
6849 
6850  /// Creates an instance over the given memory block.
6852  const void* data,
6853  EncodedLength length)
6854  : SbeMessage(data, length)
6855  {
6856  checkCompatibility();
6857  }
6858 
6859  /// Creates an instance over the given SBE message.
6860  explicit
6862  const SbeMessage& message)
6863  : SbeMessage(message)
6864  {
6865  assert(message.valid());
6866 
6867  checkCompatibility();
6868  }
6869 
6870  /// Provides access to mDSeqNum field.
6872  bool seqNum(Uint64& value) const
6874  {
6876 
6877  return ordinary(value, offset, NullUint64());
6878  }
6879 
6880  /// Provides access to rebroadcastIndicator field.
6884  {
6886 
6887  return ordinary(value, offset, NullUnsignedChar());
6888  }
6889 
6890  /// Provides access to eMM field.
6892  Emm::Enum eMM() const
6894  {
6896 
6897  return enumeration<Emm>(offset);
6898  }
6899 
6900  /// Provides access to eventTime field.
6902  bool eventTime(Uint64& value) const
6904  {
6906 
6907  return ordinary(value, offset, NullUint64());
6908  }
6909 
6910  /// \return instance of Orders repeating group.
6912  Orders orders() const
6914  {
6915  return getGroup<Orders>(OrdersAccess(), *this);
6916  }
6917 
6918  /// Minimal size of message body in bytes.
6921  static
6922  BlockLength
6926  {
6927  return
6928  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6929  18;
6930  }
6931 
6932  /// Size of message body in bytes.
6937  {
6938  return
6939  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6940  minimalBlockLength(version);
6941  }
6942 
6943  /// Minimal variable fields size (when variable-length fields are empty).
6947  static
6948  MessageSize
6951  {
6952  return
6953  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6954  static_cast<MessageSize>(Orders::EmptySize);
6955  }
6956 
6957  /// \return class name.
6961  static const Char* className()
6962  {
6963  return "LongOrderUpdate";
6964  }
6965 
6966  /// FIX message type.
6970  static StrRef fixType()
6972  {
6973  return constructStrRef("LongOrderUpdate");
6974  }
6975 
6976  /// \return a human-readable presentation.
6978  std::string toString() const;
6979 
6980 private:
6981  void checkLength(
6982  EncodedLength length, SchemaVersion version) const
6983  {
6984  const EncodedLength minimalRequiredLength =
6985  minimalBlockLength(version) +
6986  MessageHeader::Size +
6987  getMinimalVariableFieldsSize(version);
6988 
6989  checkBinaryLength(
6990  *this, length, minimalRequiredLength);
6991  }
6992 
6993  /// Checks variable fields consistency.
6994  void checkVarLenFields() const
6995  {
6996  groups().
6997  checkTail<Orders>();
6998  }
6999 
7000  void checkCompatibility() const
7001  {
7002  assert(TemplateId == templateId());
7003 
7004  checkSchema<Schema>(schemaId(), version());
7005  checkLength(bufferSize(), version());
7006  checkVarLenFields();
7007  }
7008 
7009  /// Access helper.
7010  struct OrdersAccess
7011  {
7012  Orders
7013  operator()(
7014  const LongOrderUpdate& obj) const
7016  {
7017  return obj.
7018  groups().
7019  head<Orders>();
7020  }
7021  };
7022 };
7023 
7024 /// Message identifiers and length of message root.
7027 : SbeMessage
7028 {
7029  /// Used template schema.
7031 
7032  /// Message template ID from SBE schema.
7033  enum { TemplateId = 1016 };
7034 
7035  /// Repeating group dimensions.
7036  /// Entry of PackageComponentsEntry repeating group.
7039  <
7041  >
7042  {
7043  /// Base class type.
7044  typedef
7046  <
7048  >
7050 
7051  /// Initializes instance of given
7052  /// version over given memory block.
7054  const void* data,
7055  EncodedLength length,
7056  SchemaVersion version)
7057  : Base(data, numericCast<Base::BlockLength>(length), version)
7058  {
7059  assert(version >= Schema::MinimalVersion);
7060  assert(length >= minimalBlockLength(version));
7061  }
7062 
7063  /// Provides access to legSymbolIndex field.
7065  bool legSymbolIndex(Uint32& value) const
7067  {
7069 
7070  return ordinary(value, offset, NullUint32());
7071  }
7072 
7073  /// Provides access to legRatio field.
7075  bool legRatio(Uint32& value) const
7077  {
7079 
7080  return ordinary(value, offset, NullUint32());
7081  }
7082 
7083  /// Provides access to legLastPx field.
7085  bool legLastPx(Int64& value) const
7087  {
7089 
7090  return ordinary(value, offset, NullInt64());
7091  }
7092 
7093  /// Provides access to legLastQty field.
7095  bool legLastQty(Uint64& value) const
7097  {
7099 
7100  return ordinary(value, offset, NullUint64());
7101  }
7102 
7103  /// \return size of entry body in bytes
7104  /// for given version of message template.
7109  {
7110  return
7111  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7112  minimalBlockLength(version);
7113  }
7114 
7115  /// \return minimal size of entry body in bytes
7116  /// for given version of message template.
7119  static
7120  BlockLength
7124  {
7125  return
7126  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7127  24;
7128  }
7129 
7130  /// Entity class name.
7134  static const Char* className()
7135  {
7136  return "LisPackageStructure.PackageComponentsEntry";
7137  }
7138  };
7139 
7140  /// Repeating group containing PackageComponentsEntry entries.
7141  typedef
7144 
7145  /// Initializes a blank instance.
7147 
7148  /// Creates an instance over the given memory block.
7150  const void* data,
7151  EncodedLength length)
7152  : SbeMessage(data, length)
7153  {
7154  checkCompatibility();
7155  }
7156 
7157  /// Creates an instance over the given SBE message.
7158  explicit
7160  const SbeMessage& message)
7161  : SbeMessage(message)
7162  {
7163  assert(message.valid());
7164 
7165  checkCompatibility();
7166  }
7167 
7168  /// Provides access to mDSeqNum field.
7170  bool seqNum(Uint64& value) const
7172  {
7174 
7175  return ordinary(value, offset, NullUint64());
7176  }
7177 
7178  /// Provides access to rebroadcastIndicator field.
7182  {
7184 
7185  return ordinary(value, offset, NullUnsignedChar());
7186  }
7187 
7188  /// Provides access to eMM field.
7190  Emm::Enum eMM() const
7192  {
7194 
7195  return enumeration<Emm>(offset);
7196  }
7197 
7198  /// Provides access to eventTime field.
7200  bool eventTime(Uint64& value) const
7202  {
7204 
7205  return ordinary(value, offset, NullUint64());
7206  }
7207 
7208  /// Provides access to contractSymbolIndex field.
7210  bool contractSymbolIndex(Uint32& value) const
7212  {
7214 
7215  return ordinary(value, offset, NullUint32());
7216  }
7217 
7218  /// Provides access to mifidExecutionID field.
7222  {
7225 
7226  return fixedStr<length>(offset);
7227  }
7228 
7229  /// Provides access to strategyCode field.
7233  {
7235 
7236  return enumeration<StrategyCode>(offset);
7237  }
7238 
7239  /// \return instance of PackageComponents repeating group.
7243  {
7244  return getGroup<PackageComponents>(
7245  PackageComponentsAccess(),
7246  *this);
7247  }
7248 
7249  /// Minimal size of message body in bytes.
7252  static
7253  BlockLength
7257  {
7258  return
7259  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7260  75;
7261  }
7262 
7263  /// Size of message body in bytes.
7268  {
7269  return
7270  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7271  minimalBlockLength(version);
7272  }
7273 
7274  /// Minimal variable fields size (when variable-length fields are empty).
7278  static
7279  MessageSize
7282  {
7283  return
7284  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7285  static_cast<MessageSize>(PackageComponents::EmptySize);
7286  }
7287 
7288  /// \return class name.
7292  static const Char* className()
7293  {
7294  return "LisPackageStructure";
7295  }
7296 
7297  /// FIX message type.
7301  static StrRef fixType()
7303  {
7304  return constructStrRef("LISPackageStructure");
7305  }
7306 
7307  /// \return a human-readable presentation.
7309  std::string toString() const;
7310 
7311 private:
7312  void checkLength(
7313  EncodedLength length, SchemaVersion version) const
7314  {
7315  const EncodedLength minimalRequiredLength =
7316  minimalBlockLength(version) +
7317  MessageHeader::Size +
7318  getMinimalVariableFieldsSize(version);
7319 
7320  checkBinaryLength(
7321  *this, length, minimalRequiredLength);
7322  }
7323 
7324  /// Checks variable fields consistency.
7325  void checkVarLenFields() const
7326  {
7327  groups().
7328  checkTail<PackageComponents>();
7329  }
7330 
7331  void checkCompatibility() const
7332  {
7333  assert(TemplateId == templateId());
7334 
7335  checkSchema<Schema>(schemaId(), version());
7336  checkLength(bufferSize(), version());
7337  checkVarLenFields();
7338  }
7339 
7340  /// Access helper.
7341  struct PackageComponentsAccess
7342  {
7344  operator()(
7345  const LisPackageStructure& obj) const
7347  {
7348  return obj.
7349  groups().
7350  head<PackageComponents>();
7351  }
7352  };
7353 };
7354 
7355 /// Message identifiers and length of message root.
7357 ApaQuotes
7358 : SbeMessage
7359 {
7360  /// Used template schema.
7362 
7363  /// Message template ID from SBE schema.
7364  enum { TemplateId = 1026 };
7365 
7366  /// Initializes a blank instance.
7368 
7369  /// Creates an instance over the given memory block.
7371  const void* data,
7372  EncodedLength length)
7373  : SbeMessage(data, length)
7374  {
7375  checkCompatibility();
7376  }
7377 
7378  /// Creates an instance over the given SBE message.
7379  explicit
7381  const SbeMessage& message)
7382  : SbeMessage(message)
7383  {
7384  assert(message.valid());
7385 
7386  checkCompatibility();
7387  }
7388 
7389  /// Provides access to mDSeqNum field.
7391  bool seqNum(Uint64& value) const
7393  {
7395 
7396  return ordinary(value, offset, NullUint64());
7397  }
7398 
7399  /// Provides access to rebroadcastIndicator field.
7403  {
7405 
7406  return ordinary(value, offset, NullUnsignedChar());
7407  }
7408 
7409  /// Provides access to mifidInstrumentIdType field.
7413  {
7416 
7417  return fixedStr<length>(offset);
7418  }
7419 
7420  /// Provides access to mifidInstrumentID field.
7424  {
7427 
7428  return fixedStr<length>(offset);
7429  }
7430 
7431  /// Provides access to mIC field.
7433  StrRef mIC() const
7435  {
7438 
7439  return fixedStr<length>(offset);
7440  }
7441 
7442  /// Provides access to currency field.
7446  {
7449 
7450  return fixedStr<length>(offset);
7451  }
7452 
7453  /// Provides access to lEICode field.
7455  StrRef lEICode() const
7457  {
7460 
7461  return fixedStr<length>(offset);
7462  }
7463 
7464  /// Provides access to eventTime field.
7466  bool eventTime(Uint64& value) const
7468  {
7470 
7471  return ordinary(value, offset, NullUint64());
7472  }
7473 
7474  /// Provides access to quoteUpdateType field.
7478  {
7480 
7481  return enumeration<QuoteUpdateType>(offset);
7482  }
7483 
7484  /// Provides access to mifidPrice field.
7488  {
7491 
7492  return fixedStr<length>(offset);
7493  }
7494 
7495  /// Provides access to mifidQuantity field.
7499  {
7502 
7503  return fixedStr<length>(offset);
7504  }
7505 
7506  /// Provides access to aPAOrigin field.
7508  bool aPAOrigin(StrRef& value) const
7510  {
7513 
7514  return fixedStr<length>(value, offset);
7515  }
7516 
7517  /// Minimal size of message body in bytes.
7520  static
7521  BlockLength
7525  {
7526  return
7527  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7528  105;
7529  }
7530 
7531  /// Size of message body in bytes.
7536  {
7537  return
7538  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7539  minimalBlockLength(version);
7540  }
7541 
7542  /// Minimal variable fields size (when variable-length fields are empty).
7546  static
7547  MessageSize
7550  {
7551  return
7552  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7553  0;
7554  }
7555 
7556  /// \return class name.
7560  static const Char* className()
7561  {
7562  return "ApaQuotes";
7563  }
7564 
7565  /// FIX message type.
7569  static StrRef fixType()
7571  {
7572  return constructStrRef("APAQuotes");
7573  }
7574 
7575  /// \return a human-readable presentation.
7577  std::string toString() const;
7578 
7579 private:
7580  void checkLength(
7581  EncodedLength length, SchemaVersion version) const
7582  {
7583  const EncodedLength minimalRequiredLength =
7584  minimalBlockLength(version) +
7585  MessageHeader::Size +
7586  getMinimalVariableFieldsSize(version);
7587 
7588  checkBinaryLength(
7589  *this, length, minimalRequiredLength);
7590  }
7591 
7592  void checkCompatibility() const
7593  {
7594  assert(TemplateId == templateId());
7595 
7596  checkSchema<Schema>(schemaId(), version());
7597  checkLength(bufferSize(), version());
7598  }
7599 };
7600 
7601 /// Message identifiers and length of message root.
7604 : SbeMessage
7605 {
7606  /// Used template schema.
7608 
7609  /// Message template ID from SBE schema.
7610  enum { TemplateId = 1027 };
7611 
7612  /// Initializes a blank instance.
7614 
7615  /// Creates an instance over the given memory block.
7617  const void* data,
7618  EncodedLength length)
7619  : SbeMessage(data, length)
7620  {
7621  checkCompatibility();
7622  }
7623 
7624  /// Creates an instance over the given SBE message.
7625  explicit
7627  const SbeMessage& message)
7628  : SbeMessage(message)
7629  {
7630  assert(message.valid());
7631 
7632  checkCompatibility();
7633  }
7634 
7635  /// Provides access to mDSeqNum field.
7637  bool seqNum(Uint64& value) const
7639  {
7641 
7642  return ordinary(value, offset, NullUint64());
7643  }
7644 
7645  /// Provides access to rebroadcastIndicator field.
7649  {
7651 
7652  return ordinary(value, offset, NullUnsignedChar());
7653  }
7654 
7655  /// Provides access to mifidInstrumentIdType field.
7659  {
7662 
7663  return fixedStr<length>(offset);
7664  }
7665 
7666  /// Provides access to mifidInstrumentID field.
7670  {
7673 
7674  return fixedStr<length>(offset);
7675  }
7676 
7677  /// Provides access to fullInstrumentName field.
7679  bool fullInstrumentName(StrRef& value) const
7681  {
7684 
7685  return fixedStr<length>(value, offset);
7686  }
7687 
7688  /// Provides access to cFI field.
7690  bool cFI(StrRef& value) const
7692  {
7695 
7696  return fixedStr<length>(value, offset);
7697  }
7698 
7699  /// Provides access to notionalCurrency field.
7701  bool notionalCurrency(StrRef& value) const
7703  {
7706 
7707  return fixedStr<length>(value, offset);
7708  }
7709 
7710  /// Provides access to secondNotionalCurrency field.
7712  bool secondNotionalCurrency(StrRef& value) const
7714  {
7717 
7718  return fixedStr<length>(value, offset);
7719  }
7720 
7721  /// Provides access to priceMultiplier field.
7723  bool priceMultiplier(Uint32& value) const
7725  {
7727 
7728  return ordinary(value, offset, NullUint32());
7729  }
7730 
7731  /// Provides access to priceMultiplierDecimals field.
7735  {
7737 
7738  return ordinary(value, offset, NullUnsignedChar());
7739  }
7740 
7741  /// Provides access to underlyingISINCode field.
7743  bool underlyingISINCode(StrRef& value) const
7745  {
7748 
7749  return fixedStr<length>(value, offset);
7750  }
7751 
7752  /// Provides access to underlyingIndexName field.
7754  bool underlyingIndexName(StrRef& value) const
7756  {
7759 
7760  return fixedStr<length>(value, offset);
7761  }
7762 
7763  /// Provides access to underlyingIndexTerm field.
7765  bool underlyingIndexTerm(StrRef& value) const
7767  {
7770 
7771  return fixedStr<length>(value, offset);
7772  }
7773 
7774  /// Provides access to optionType field.
7776  bool optionType(OptionType::Enum& value) const
7778  {
7780 
7781  return enumeration<OptionType>(value, offset, NullUInt8());
7782  }
7783 
7784  /// Provides access to strikePrice field.
7786  bool strikePrice(Int64& value) const
7788  {
7790 
7791  return ordinary(value, offset, NullInt64());
7792  }
7793 
7794  /// Provides access to strikePriceDecimals field.
7798  {
7800 
7801  return ordinary(value, offset, NullUnsignedChar());
7802  }
7803 
7804  /// Provides access to exerStyle field.
7806  bool
7808  ExerciseStyle::Enum& value) const
7810  {
7812 
7813  return enumeration<ExerciseStyle>(value, offset, NullUInt8());
7814  }
7815 
7816  /// Provides access to maturityDate field.
7818  bool maturityDate(StrRef& value) const
7820  {
7823 
7824  return fixedStr<length>(value, offset);
7825  }
7826 
7827  /// Provides access to expiryDate field.
7829  bool expiryDate(StrRef& value) const
7831  {
7834 
7835  return fixedStr<length>(value, offset);
7836  }
7837 
7838  /// Provides access to settlementMethod field.
7840  bool settlementMethod(Char& value) const
7842  {
7844 
7845  return ordinary(value, offset, NullChar());
7846  }
7847 
7848  /// Minimal size of message body in bytes.
7851  static
7852  BlockLength
7856  {
7857  return
7858  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7859  217;
7860  }
7861 
7862  /// Size of message body in bytes.
7867  {
7868  return
7869  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7870  minimalBlockLength(version);
7871  }
7872 
7873  /// Minimal variable fields size (when variable-length fields are empty).
7877  static
7878  MessageSize
7881  {
7882  return
7883  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7884  0;
7885  }
7886 
7887  /// \return class name.
7891  static const Char* className()
7892  {
7893  return "ApaStandingData";
7894  }
7895 
7896  /// FIX message type.
7900  static StrRef fixType()
7902  {
7903  return constructStrRef("APAStandingData");
7904  }
7905 
7906  /// \return a human-readable presentation.
7908  std::string toString() const;
7909 
7910 private:
7911  void checkLength(
7912  EncodedLength length, SchemaVersion version) const
7913  {
7914  const EncodedLength minimalRequiredLength =
7915  minimalBlockLength(version) +
7916  MessageHeader::Size +
7917  getMinimalVariableFieldsSize(version);
7918 
7919  checkBinaryLength(
7920  *this, length, minimalRequiredLength);
7921  }
7922 
7923  void checkCompatibility() const
7924  {
7925  assert(TemplateId == templateId());
7926 
7927  checkSchema<Schema>(schemaId(), version());
7928  checkLength(bufferSize(), version());
7929  }
7930 };
7931 
7932 /// Message identifiers and length of message root.
7935 : SbeMessage
7936 {
7937  /// Used template schema.
7939 
7940  /// Message template ID from SBE schema.
7941  enum { TemplateId = 1028 };
7942 
7943  /// Initializes a blank instance.
7945 
7946  /// Creates an instance over the given memory block.
7948  const void* data,
7949  EncodedLength length)
7950  : SbeMessage(data, length)
7951  {
7952  checkCompatibility();
7953  }
7954 
7955  /// Creates an instance over the given SBE message.
7956  explicit
7958  const SbeMessage& message)
7959  : SbeMessage(message)
7960  {
7961  assert(message.valid());
7962 
7963  checkCompatibility();
7964  }
7965 
7966  /// Provides access to mDSeqNum field.
7968  bool seqNum(Uint64& value) const
7970  {
7972 
7973  return ordinary(value, offset, NullUint64());
7974  }
7975 
7976  /// Provides access to rebroadcastIndicator field.
7980  {
7982 
7983  return ordinary(value, offset, NullUnsignedChar());
7984  }
7985 
7986  /// Provides access to eMM field.
7988  Emm::Enum eMM() const
7990  {
7992 
7993  return enumeration<Emm>(offset);
7994  }
7995 
7996  /// Provides access to eventTime field.
7998  bool eventTime(Uint64& value) const
8000  {
8002 
8003  return ordinary(value, offset, NullUint64());
8004  }
8005 
8006  /// Provides access to tradingDateTime field.
8010  {
8013 
8014  return fixedStr<length>(offset);
8015  }
8016 
8017  /// Provides access to publicationDateTime field.
8019  bool publicationDateTime(StrRef& value) const
8021  {
8024 
8025  return fixedStr<length>(value, offset);
8026  }
8027 
8028  /// Provides access to tradeType field.
8032  {
8034 
8035  return enumeration<TradeType>(offset);
8036  }
8037 
8038  /// Provides access to mifidInstrumentIdType field.
8040  bool mifidInstrumentIdType(StrRef& value) const
8042  {
8045 
8046  return fixedStr<length>(value, offset);
8047  }
8048 
8049  /// Provides access to mifidInstrumentID field.
8051  bool mifidInstrumentId(StrRef& value) const
8053  {
8056 
8057  return fixedStr<length>(value, offset);
8058  }
8059 
8060  /// Provides access to miFIDTransactionID field.
8064  {
8067 
8068  return fixedStr<length>(offset);
8069  }
8070 
8071  /// Provides access to mifidPrice field.
8073  bool mifidPrice(StrRef& value) const
8075  {
8078 
8079  return fixedStr<length>(value, offset);
8080  }
8081 
8082  /// Provides access to mifidQuantity field.
8086  {
8089 
8090  return fixedStr<length>(offset);
8091  }
8092 
8093  /// Provides access to mifidPriceNotation field.
8095  bool mifidPriceNotation(StrRef& value) const
8097  {
8100 
8101  return fixedStr<length>(value, offset);
8102  }
8103 
8104  /// Provides access to mifidCurrency field.
8106  bool mifidCurrency(StrRef& value) const
8108  {
8111 
8112  return fixedStr<length>(value, offset);
8113  }
8114 
8115  /// Provides access to miFIDQtyinMsrmtUnitNotation field.
8119  {
8122 
8123  return fixedStr<length>(value, offset);
8124  }
8125 
8126  /// Provides access to mifidQuantityMeasurementUnit field.
8130  {
8133 
8134  return fixedStr<length>(value, offset);
8135  }
8136 
8137  /// Provides access to miFIDNotionalAmount field.
8139  bool miFIdNotionalAmount(StrRef& value) const
8141  {
8144 
8145  return fixedStr<length>(value, offset);
8146  }
8147 
8148  /// Provides access to notionalCurrency field.
8150  bool notionalCurrency(StrRef& value) const
8152  {
8155 
8156  return fixedStr<length>(value, offset);
8157  }
8158 
8159  /// Provides access to miFIDClearingFlag field.
8161  bool miFIdClearingFlag(StrRef& value) const
8163  {
8166 
8167  return fixedStr<length>(value, offset);
8168  }
8169 
8170  /// Provides access to efficientMMTMarketMechanism field.
8172  bool
8174  EfficientMMTMarketMechanism::Enum& value) const
8176  {
8178 
8179  return enumeration<EfficientMMTMarketMechanism>(value, offset, NullUInt8());
8180  }
8181 
8182  /// Provides access to efficientMMTTradingMode field.
8184  bool
8186  EfficientMMTTradingMode::Enum& value) const
8188  {
8190 
8191  return enumeration<EfficientMMTTradingMode>(value, offset, NullChar());
8192  }
8193 
8194  /// Provides access to efficientMMTTransactionCategory field.
8196  bool
8200  {
8202 
8203  return enumeration<EfficientMMTTransactionCategory>(value, offset, NullChar());
8204  }
8205 
8206  /// Provides access to efficientMMTNegotiationIndicator field.
8208  bool
8212  {
8214 
8215  return enumeration<EfficientMMTNegotiationIndicator>(value, offset, NullChar());
8216  }
8217 
8218  /// Provides access to efficientMMTAgencyCrossTradeIndicator field.
8220  bool
8224  {
8226 
8227  return enumeration<EfficientMMTAgencyCrossTradeIndicator>(value, offset, NullChar());
8228  }
8229 
8230  /// Provides access to efficientMMTModificationIndicator field.
8232  bool
8236  {
8238 
8239  return enumeration<EfficientMMTModificationIndicator>(value, offset, NullChar());
8240  }
8241 
8242  /// Provides access to efficientMMTBenchmarkIndicator field.
8244  bool
8248  {
8250 
8251  return enumeration<EfficientMMTBenchmarkIndicator>(value, offset, NullChar());
8252  }
8253 
8254  /// Provides access to efficientMMTSpecialDividendIndicator field.
8256  bool
8260  {
8262 
8263  return enumeration<EfficientMMTSpecialDividendIndicator>(value, offset, NullChar());
8264  }
8265 
8266  /// Provides access to efficientMMTOffBookAutomatedIndicator field.
8268  bool
8272  {
8274 
8275  return enumeration<EfficientMMTOffBookAutomatedIndicator>(value, offset, NullChar());
8276  }
8277 
8278  /// Provides access to efficientMMTContributiontoPrice field.
8280  bool
8284  {
8286 
8287  return enumeration<EfficientMMTContributiontoPrice>(value, offset, NullChar());
8288  }
8289 
8290  /// Provides access to efficientMMTAlgorithmicIndicator field.
8292  bool
8296  {
8298 
8299  return enumeration<EfficientMMTAlgorithmicIndicator>(value, offset, NullChar());
8300  }
8301 
8302  /// Provides access to efficientMMTPublicationMode field.
8304  bool
8306  EfficientMMTPublicationMode::Enum& value) const
8308  {
8310 
8311  return enumeration<EfficientMMTPublicationMode>(value, offset, NullChar());
8312  }
8313 
8314  /// Provides access to efficientMMTPostTradeDeferral field.
8316  bool
8320  {
8322 
8323  return enumeration<EfficientMMTPostTradeDeferral>(value, offset, NullChar());
8324  }
8325 
8326  /// Provides access to efficientMMTDuplicativeIndicator field.
8328  bool
8332  {
8334 
8335  return enumeration<EfficientMMTDuplicativeIndicator>(value, offset, NullChar());
8336  }
8337 
8338  /// Provides access to tradeReference field.
8340  bool tradeReference(StrRef& value) const
8342  {
8345 
8346  return fixedStr<length>(value, offset);
8347  }
8348 
8349  /// Provides access to originalReportTimestamp field.
8351  bool originalReportTimestamp(Uint64& value) const
8353  {
8355 
8356  return ordinary(value, offset, NullUint64());
8357  }
8358 
8359  /// Provides access to priceMultiplier field.
8361  bool priceMultiplier(Uint32& value) const
8363  {
8365 
8366  return ordinary(value, offset, NullUint32());
8367  }
8368 
8369  /// Provides access to priceMultiplierDecimals field.
8373  {
8375 
8376  return ordinary(value, offset, NullUnsignedChar());
8377  }
8378 
8379  /// Provides access to venue field.
8381  StrRef venue() const
8383  {
8386 
8387  return fixedStr<length>(offset);
8388  }
8389 
8390  /// Provides access to miFIDEmissionAllowanceType field.
8394  {
8397 
8398  return fixedStr<length>(value, offset);
8399  }
8400 
8401  /// Provides access to longTradeReference field.
8403  bool longTradeReference(StrRef& value) const
8405  {
8408 
8409  return fixedStr<length>(value, offset);
8410  }
8411 
8412  /// Provides access to aPAOrigin field.
8414  bool aPAOrigin(StrRef& value) const
8416  {
8419 
8420  return fixedStr<length>(value, offset);
8421  }
8422 
8423  /// Provides access to tradeUniqueIdentifier field.
8425  bool tradeUniqueIdentifier(StrRef& value) const
8427  {
8431 
8432  return fixedStr<length>(value, offset, since);
8433  }
8434 
8435  /// Minimal size of message body in bytes.
8440  {
8441  return
8442  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8443  (version >= 316)
8444  ? 405
8445  : 389;
8446  }
8447 
8448  /// Size of message body in bytes.
8453  {
8454  return
8455  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8456  minimalBlockLength(version);
8457  }
8458 
8459  /// Minimal variable fields size (when variable-length fields are empty).
8463  static
8464  MessageSize
8467  {
8468  return
8469  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8470  0;
8471  }
8472 
8473  /// \return class name.
8477  static const Char* className()
8478  {
8479  return "ApaFullTradeInformation";
8480  }
8481 
8482  /// FIX message type.
8486  static StrRef fixType()
8488  {
8489  return constructStrRef(
8490  "APAFullTradeInformation");
8491  }
8492 
8493  /// \return a human-readable presentation.
8495  std::string toString() const;
8496 
8497 private:
8498  void checkLength(
8499  EncodedLength length, SchemaVersion version) const
8500  {
8501  const EncodedLength minimalRequiredLength =
8502  minimalBlockLength(version) +
8503  MessageHeader::Size +
8504  getMinimalVariableFieldsSize(version);
8505 
8506  checkBinaryLength(
8507  *this, length, minimalRequiredLength);
8508  }
8509 
8510  void checkCompatibility() const
8511  {
8512  assert(TemplateId == templateId());
8513 
8514  checkSchema<Schema>(schemaId(), version());
8515  checkLength(bufferSize(), version());
8516  }
8517 };
8518 
8519 /// Message identifiers and length of message root.
8522 : SbeMessage
8523 {
8524  /// Used template schema.
8526 
8527  /// Message template ID from SBE schema.
8528  enum { TemplateId = 1201 };
8529 
8530  /// Repeating group dimensions.
8531  /// Entry of InterestPaymentDateRepEntry repeating group.
8534  <
8536  >
8537  {
8538  /// Base class type.
8539  typedef
8541  <
8543  >
8545 
8546  /// Initializes instance of given
8547  /// version over given memory block.
8549  const void* data,
8550  EncodedLength length,
8551  SchemaVersion version)
8552  : Base(data, numericCast<Base::BlockLength>(length), version)
8553  {
8554  assert(version >= Schema::MinimalVersion);
8555  assert(length >= minimalBlockLength(version));
8556  }
8557 
8558  /// Provides access to interestPaymentDate field.
8560  bool interestPaymentDate(Uint16& value) const
8562  {
8564 
8565  return ordinary(value, offset, NullUint16());
8566  }
8567 
8568  /// \return size of entry body in bytes
8569  /// for given version of message template.
8574  {
8575  return
8576  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8577  minimalBlockLength(version);
8578  }
8579 
8580  /// \return minimal size of entry body in bytes
8581  /// for given version of message template.
8584  static
8585  BlockLength
8589  {
8590  return
8591  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8592  2;
8593  }
8594 
8595  /// Entity class name.
8599  static const Char* className()
8600  {
8601  return "BfInstrumentReference.InterestPaymentDateRepEntry";
8602  }
8603  };
8604 
8605  /// Repeating group containing InterestPaymentDateRepEntry entries.
8606  typedef
8609 
8610  /// Initializes a blank instance.
8612 
8613  /// Creates an instance over the given memory block.
8615  const void* data,
8616  EncodedLength length)
8617  : SbeMessage(data, length)
8618  {
8619  checkCompatibility();
8620  }
8621 
8622  /// Creates an instance over the given SBE message.
8623  explicit
8625  const SbeMessage& message)
8626  : SbeMessage(message)
8627  {
8628  assert(message.valid());
8629 
8630  checkCompatibility();
8631  }
8632 
8633  /// Provides access to mDSeqNum field.
8635  bool seqNum(Uint64& value) const
8637  {
8639 
8640  return ordinary(value, offset, NullUint64());
8641  }
8642 
8643  /// Provides access to rebroadcastIndicator field.
8647  {
8649 
8650  return ordinary(value, offset, NullUnsignedChar());
8651  }
8652 
8653  /// Provides access to symbolIndex field.
8655  bool symbolIndex(Uint32& value) const
8657  {
8659 
8660  return ordinary(value, offset, NullUint32());
8661  }
8662 
8663  /// Provides access to optiqSegment field.
8667  {
8669 
8670  return enumeration<OptiqSegment>(offset);
8671  }
8672 
8673  /// Provides access to iSINCode field.
8675  bool iSINCode(StrRef& value) const
8677  {
8680 
8681  return fixedStr<length>(value, offset);
8682  }
8683 
8684  /// Provides access to sEDOLCode field.
8686  bool sEDOLCode(StrRef& value) const
8688  {
8691 
8692  return fixedStr<length>(value, offset);
8693  }
8694 
8695  /// Provides access to longIssuerName field.
8697  bool longIssuerName(StrRef& value) const
8699  {
8702 
8703  return fixedStr<length>(value, offset);
8704  }
8705 
8706  /// Provides access to longInstrumentName field.
8708  bool longInstrumentName(StrRef& value) const
8710  {
8713 
8714  return fixedStr<length>(value, offset);
8715  }
8716 
8717  /// Provides access to currency field.
8719  bool currency(StrRef& value) const
8721  {
8724 
8725  return fixedStr<length>(value, offset);
8726  }
8727 
8728  /// Provides access to dateOfInitialListing field.
8730  bool dateOfInitialListing(Uint16& value) const
8732  {
8734 
8735  return ordinary(value, offset, NullUint16());
8736  }
8737 
8738  /// Provides access to shareAmountInIssue field.
8740  bool shareAmountInIssue(Int64& value) const
8742  {
8744 
8745  return ordinary(value, offset, NullInt64());
8746  }
8747 
8748  /// Provides access to openedClosedFund field.
8750  bool
8752  OpenedClosedFund::Enum& value) const
8754  {
8756 
8757  return enumeration<OpenedClosedFund>(value, offset, NullChar());
8758  }
8759 
8760  /// Provides access to lastNAVPrice field.
8762  bool lastNAVPrice(Int64& value) const
8764  {
8766 
8767  return ordinary(value, offset, NullInt64());
8768  }
8769 
8770  /// Provides access to grossOfCDSCIndicator field.
8772  bool
8774  GrossofCDSCIndicator::Enum& value) const
8776  {
8778 
8779  return enumeration<GrossofCDSCIndicator>(value, offset, NullChar());
8780  }
8781 
8782  /// Provides access to coupon field.
8784  bool coupon(Int64& value) const
8786  {
8788 
8789  return ordinary(value, offset, NullInt64());
8790  }
8791 
8792  /// Provides access to maturityDate field.
8794  bool maturityDate(StrRef& value) const
8796  {
8799 
8800  return fixedStr<length>(value, offset);
8801  }
8802 
8803  /// Provides access to closingPrice field.
8805  bool closingPrice(Int64& value) const
8807  {
8809 
8810  return ordinary(value, offset, NullInt64());
8811  }
8812 
8813  /// Provides access to mIC field.
8815  bool mIC(StrRef& value) const
8817  {
8820 
8821  return fixedStr<length>(value, offset);
8822  }
8823 
8824  /// Provides access to grossDividendPayablePerUnit field.
8828  {
8830 
8831  return ordinary(value, offset, NullInt64());
8832  }
8833 
8834  /// Provides access to dividendCurrency field.
8836  bool dividendCurrency(StrRef& value) const
8838  {
8841 
8842  return fixedStr<length>(value, offset);
8843  }
8844 
8845  /// Provides access to dividendRecordDate field.
8847  bool dividendRecordDate(Uint16& value) const
8849  {
8851 
8852  return ordinary(value, offset, NullUint16());
8853  }
8854 
8855  /// Provides access to dividendRate field.
8857  bool dividendRate(Uint64& value) const
8859  {
8861 
8862  return ordinary(value, offset, NullUint64());
8863  }
8864 
8865  /// Provides access to exDividendDate field.
8867  bool exDividendDate(Uint16& value) const
8869  {
8871 
8872  return ordinary(value, offset, NullUint16());
8873  }
8874 
8875  /// Provides access to dividendPaymentDate field.
8877  bool dividendPaymentDate(Uint16& value) const
8879  {
8881 
8882  return ordinary(value, offset, NullUint16());
8883  }
8884 
8885  /// Provides access to taxDescriptionAttachingToADividend field.
8887  bool
8891  {
8893 
8894  return enumeration<TaxDescriptionAttachingtoaDividend>(value, offset, NullChar());
8895  }
8896 
8897  /// Provides access to nextMeeting field.
8899  bool nextMeeting(StrRef& value) const
8901  {
8904 
8905  return fixedStr<length>(value, offset);
8906  }
8907 
8908  /// Provides access to grossDividendInEuros field.
8910  bool grossDividendInEuros(Int64& value) const
8912  {
8914 
8915  return ordinary(value, offset, NullInt64());
8916  }
8917 
8918  /// Provides access to issueDate field.
8920  bool issueDate(Uint16& value) const
8922  {
8924 
8925  return ordinary(value, offset, NullUint16());
8926  }
8927 
8928  /// Provides access to issuingCountry field.
8930  bool issuingCountry(StrRef& value) const
8932  {
8935 
8936  return fixedStr<length>(value, offset);
8937  }
8938 
8939  /// Provides access to cFI field.
8941  bool cFI(StrRef& value) const
8943  {
8946 
8947  return fixedStr<length>(value, offset);
8948  }
8949 
8950  /// Provides access to paymentFrequency field.
8952  bool
8954  PaymentFrequency::Enum& value) const
8956  {
8958 
8959  return enumeration<PaymentFrequency>(value, offset, NullUInt8());
8960  }
8961 
8962  /// Provides access to minimumAmount field.
8964  bool minimumAmount(Int64& value) const
8966  {
8968 
8969  return ordinary(value, offset, NullInt64());
8970  }
8971 
8972  /// Provides access to instrumentCategory field.
8976  {
8978 
8979  return enumeration<InstrumentCategory>(offset);
8980  }
8981 
8982  /// Provides access to securityCondition field.
8984  bool
8986  SecurityCondition::Enum& value) const
8988  {
8990 
8991  return enumeration<SecurityCondition>(value, offset, NullChar());
8992  }
8993 
8994  /// Provides access to miFIDPriceNotation field.
8996  bool miFIdPriceNotation(StrRef& value) const
8998  {
9001 
9002  return fixedStr<length>(value, offset);
9003  }
9004 
9005  /// Provides access to priceIndexLevelDecimals field.
9009  {
9011 
9012  return ordinary(value, offset, NullUnsignedChar());
9013  }
9014 
9015  /// Provides access to quantityDecimals field.
9017  bool quantityDecimals(UnsignedChar& value) const
9019  {
9021 
9022  return ordinary(value, offset, NullUnsignedChar());
9023  }
9024 
9025  /// Provides access to amountDecimals field.
9027  bool amountDecimals(UnsignedChar& value) const
9029  {
9031 
9032  return ordinary(value, offset, NullUnsignedChar());
9033  }
9034 
9035  /// Provides access to ratioMultiplierDecimals field.
9039  {
9041 
9042  return ordinary(value, offset, NullUnsignedChar());
9043  }
9044 
9045  /// \return instance of InterestPaymentDateRep repeating group.
9049  {
9050  return getGroup<InterestPaymentDateRep>(
9051  InterestPaymentDateRepAccess(),
9052  *this);
9053  }
9054 
9055  /// Minimal size of message body in bytes.
9058  static
9059  BlockLength
9063  {
9064  return
9065  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9066  656;
9067  }
9068 
9069  /// Size of message body in bytes.
9074  {
9075  return
9076  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9077  minimalBlockLength(version);
9078  }
9079 
9080  /// Minimal variable fields size (when variable-length fields are empty).
9084  static
9085  MessageSize
9088  {
9089  return
9090  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9091  static_cast<MessageSize>(InterestPaymentDateRep::EmptySize);
9092  }
9093 
9094  /// \return class name.
9098  static const Char* className()
9099  {
9100  return "BfInstrumentReference";
9101  }
9102 
9103  /// FIX message type.
9107  static StrRef fixType()
9109  {
9110  return constructStrRef("BFInstrumentReference");
9111  }
9112 
9113  /// \return a human-readable presentation.
9115  std::string toString() const;
9116 
9117 private:
9118  void checkLength(
9119  EncodedLength length, SchemaVersion version) const
9120  {
9121  const EncodedLength minimalRequiredLength =
9122  minimalBlockLength(version) +
9123  MessageHeader::Size +
9124  getMinimalVariableFieldsSize(version);
9125 
9126  checkBinaryLength(
9127  *this, length, minimalRequiredLength);
9128  }
9129 
9130  /// Checks variable fields consistency.
9131  void checkVarLenFields() const
9132  {
9133  groups().
9134  checkTail<InterestPaymentDateRep>();
9135  }
9136 
9137  void checkCompatibility() const
9138  {
9139  assert(TemplateId == templateId());
9140 
9141  checkSchema<Schema>(schemaId(), version());
9142  checkLength(bufferSize(), version());
9143  checkVarLenFields();
9144  }
9145 
9146  /// Access helper.
9147  struct InterestPaymentDateRepAccess
9148  {
9150  operator()(
9151  const BfInstrumentReference& obj) const
9153  {
9154  return obj.
9155  groups().
9156  head<InterestPaymentDateRep>();
9157  }
9158  };
9159 };
9160 
9161 /// Message identifiers and length of message root.
9163 BfTrade
9164 : SbeMessage
9165 {
9166  /// Used template schema.
9168 
9169  /// Message template ID from SBE schema.
9170  enum { TemplateId = 1202 };
9171 
9172  /// Initializes a blank instance.
9174 
9175  /// Creates an instance over the given memory block.
9177  const void* data,
9178  EncodedLength length)
9179  : SbeMessage(data, length)
9180  {
9181  checkCompatibility();
9182  }
9183 
9184  /// Creates an instance over the given SBE message.
9185  explicit
9187  const SbeMessage& message)
9188  : SbeMessage(message)
9189  {
9190  assert(message.valid());
9191 
9192  checkCompatibility();
9193  }
9194 
9195  /// Provides access to mDSeqNum field.
9197  bool seqNum(Uint64& value) const
9199  {
9201 
9202  return ordinary(value, offset, NullUint64());
9203  }
9204 
9205  /// Provides access to rebroadcastIndicator field.
9209  {
9211 
9212  return ordinary(value, offset, NullUnsignedChar());
9213  }
9214 
9215  /// Provides access to symbolIndex field.
9217  bool symbolIndex(Uint32& value) const
9219  {
9221 
9222  return ordinary(value, offset, NullUint32());
9223  }
9224 
9225  /// Provides access to miFIDTransactionID field.
9229  {
9232 
9233  return fixedStr<length>(offset);
9234  }
9235 
9236  /// Provides access to eventTime field.
9238  bool eventTime(Uint64& value) const
9240  {
9242 
9243  return ordinary(value, offset, NullUint64());
9244  }
9245 
9246  /// Provides access to bidOfferDateTime field.
9248  bool bidOfferDateTime(Uint64& value) const
9250  {
9252 
9253  return ordinary(value, offset, NullUint64());
9254  }
9255 
9256  /// Provides access to mMTModificationIndicator field.
9260  {
9263 
9264  return fixedStr<length>(offset);
9265  }
9266 
9267  /// Provides access to price field.
9269  bool price(Int64& value) const
9271  {
9273 
9274  return ordinary(value, offset, NullInt64());
9275  }
9276 
9277  /// Provides access to bidPrice field.
9279  bool bidPrice(Int64& value) const
9281  {
9283 
9284  return ordinary(value, offset, NullInt64());
9285  }
9286 
9287  /// Provides access to offerPrice field.
9289  bool offerPrice(Int64& value) const
9291  {
9293 
9294  return ordinary(value, offset, NullInt64());
9295  }
9296 
9297  /// Provides access to quantity field.
9299  bool quantity(Uint64& value) const
9301  {
9303 
9304  return ordinary(value, offset, NullUint64());
9305  }
9306 
9307  /// Provides access to mMTAgencyCrossTradeIndicator field.
9311  {
9314 
9315  return fixedStr<length>(value, offset);
9316  }
9317 
9318  /// Provides access to mMTBenchmarkIndicator field.
9320  bool mMTBenchmarkIndicator(StrRef& value) const
9322  {
9325 
9326  return fixedStr<length>(value, offset);
9327  }
9328 
9329  /// Provides access to mMTSpecialDividendIndicator field.
9333  {
9336 
9337  return fixedStr<length>(value, offset);
9338  }
9339 
9340  /// Provides access to mMTTradingMode field.
9342  bool
9344  MmtTradingMode::Enum& value) const
9346  {
9348 
9349  return enumeration<MmtTradingMode>(value, offset, NullChar());
9350  }
9351 
9352  /// Provides access to miFIDPriceNotation field.
9354  bool miFIdPriceNotation(StrRef& value) const
9356  {
9359 
9360  return fixedStr<length>(value, offset);
9361  }
9362 
9363  /// Provides access to quantityNotation field.
9365  bool quantityNotation(StrRef& value) const
9367  {
9370 
9371  return fixedStr<length>(value, offset);
9372  }
9373 
9374  /// Provides access to notionalAmountTraded field.
9376  bool notionalAmountTraded(Int64& value) const
9378  {
9380 
9381  return ordinary(value, offset, NullInt64());
9382  }
9383 
9384  /// Provides access to tradingCurrency field.
9386  bool tradingCurrency(StrRef& value) const
9388  {
9391 
9392  return fixedStr<length>(value, offset);
9393  }
9394 
9395  /// Minimal size of message body in bytes.
9398  static
9399  BlockLength
9403  {
9404  return
9405  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9406  148;
9407  }
9408 
9409  /// Size of message body in bytes.
9414  {
9415  return
9416  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9417  minimalBlockLength(version);
9418  }
9419 
9420  /// Minimal variable fields size (when variable-length fields are empty).
9424  static
9425  MessageSize
9428  {
9429  return
9430  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9431  0;
9432  }
9433 
9434  /// \return class name.
9438  static const Char* className()
9439  {
9440  return "BfTrade";
9441  }
9442 
9443  /// FIX message type.
9447  static StrRef fixType()
9449  {
9450  return constructStrRef("BFTrade");
9451  }
9452 
9453  /// \return a human-readable presentation.
9455  std::string toString() const;
9456 
9457 private:
9458  void checkLength(
9459  EncodedLength length, SchemaVersion version) const
9460  {
9461  const EncodedLength minimalRequiredLength =
9462  minimalBlockLength(version) +
9463  MessageHeader::Size +
9464  getMinimalVariableFieldsSize(version);
9465 
9466  checkBinaryLength(
9467  *this, length, minimalRequiredLength);
9468  }
9469 
9470  void checkCompatibility() const
9471  {
9472  assert(TemplateId == templateId());
9473 
9474  checkSchema<Schema>(schemaId(), version());
9475  checkLength(bufferSize(), version());
9476  }
9477 };
9478 
9479 /// Message identifiers and length of message root.
9481 Bfnav
9482 : SbeMessage
9483 {
9484  /// Used template schema.
9486 
9487  /// Message template ID from SBE schema.
9488  enum { TemplateId = 1203 };
9489 
9490  /// Initializes a blank instance.
9492 
9493  /// Creates an instance over the given memory block.
9495  const void* data,
9496  EncodedLength length)
9497  : SbeMessage(data, length)
9498  {
9499  checkCompatibility();
9500  }
9501 
9502  /// Creates an instance over the given SBE message.
9503  explicit
9505  const SbeMessage& message)
9506  : SbeMessage(message)
9507  {
9508  assert(message.valid());
9509 
9510  checkCompatibility();
9511  }
9512 
9513  /// Provides access to mDSeqNum field.
9515  bool seqNum(Uint64& value) const
9517  {
9519 
9520  return ordinary(value, offset, NullUint64());
9521  }
9522 
9523  /// Provides access to rebroadcastIndicator field.
9527  {
9529 
9530  return ordinary(value, offset, NullUnsignedChar());
9531  }
9532 
9533  /// Provides access to symbolIndex field.
9535  bool symbolIndex(Uint32& value) const
9537  {
9539 
9540  return ordinary(value, offset, NullUint32());
9541  }
9542 
9543  /// Provides access to bidOfferDateTime field.
9545  bool bidOfferDateTime(Uint64& value) const
9547  {
9549 
9550  return ordinary(value, offset, NullUint64());
9551  }
9552 
9553  /// Provides access to miFIDTransactionID field.
9557  {
9560 
9561  return fixedStr<length>(offset);
9562  }
9563 
9564  /// Provides access to mMTModificationIndicator field.
9568  {
9571 
9572  return fixedStr<length>(offset);
9573  }
9574 
9575  /// Provides access to nAVPrice field.
9577  bool nAVPrice(Int64& value) const
9579  {
9581 
9582  return ordinary(value, offset, NullInt64());
9583  }
9584 
9585  /// Provides access to eventTime field.
9587  bool eventTime(Uint64& value) const
9589  {
9591 
9592  return ordinary(value, offset, NullUint64());
9593  }
9594 
9595  /// Provides access to nAVBidPrice field.
9597  bool nAVBidPrice(Int64& value) const
9599  {
9601 
9602  return ordinary(value, offset, NullInt64());
9603  }
9604 
9605  /// Provides access to nAVOfferPrice field.
9607  bool nAVOfferPrice(Int64& value) const
9609  {
9611 
9612  return ordinary(value, offset, NullInt64());
9613  }
9614 
9615  /// Minimal size of message body in bytes.
9618  static
9619  BlockLength
9623  {
9624  return
9625  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9626  109;
9627  }
9628 
9629  /// Size of message body in bytes.
9634  {
9635  return
9636  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9637  minimalBlockLength(version);
9638  }
9639 
9640  /// Minimal variable fields size (when variable-length fields are empty).
9644  static
9645  MessageSize
9648  {
9649  return
9650  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9651  0;
9652  }
9653 
9654  /// \return class name.
9658  static const Char* className()
9659  {
9660  return "Bfnav";
9661  }
9662 
9663  /// FIX message type.
9667  static StrRef fixType()
9669  {
9670  return constructStrRef("BFNAV");
9671  }
9672 
9673  /// \return a human-readable presentation.
9675  std::string toString() const;
9676 
9677 private:
9678  void checkLength(
9679  EncodedLength length, SchemaVersion version) const
9680  {
9681  const EncodedLength minimalRequiredLength =
9682  minimalBlockLength(version) +
9683  MessageHeader::Size +
9684  getMinimalVariableFieldsSize(version);
9685 
9686  checkBinaryLength(
9687  *this, length, minimalRequiredLength);
9688  }
9689 
9690  void checkCompatibility() const
9691  {
9692  assert(TemplateId == templateId());
9693 
9694  checkSchema<Schema>(schemaId(), version());
9695  checkLength(bufferSize(), version());
9696  }
9697 };
9698 
9699 /// Message identifiers and length of message root.
9702 : SbeMessage
9703 {
9704  /// Used template schema.
9706 
9707  /// Message template ID from SBE schema.
9708  enum { TemplateId = 1204 };
9709 
9710  /// Initializes a blank instance.
9712 
9713  /// Creates an instance over the given memory block.
9715  const void* data,
9716  EncodedLength length)
9717  : SbeMessage(data, length)
9718  {
9719  checkCompatibility();
9720  }
9721 
9722  /// Creates an instance over the given SBE message.
9723  explicit
9725  const SbeMessage& message)
9726  : SbeMessage(message)
9727  {
9728  assert(message.valid());
9729 
9730  checkCompatibility();
9731  }
9732 
9733  /// Provides access to mDSeqNum field.
9735  bool seqNum(Uint64& value) const
9737  {
9739 
9740  return ordinary(value, offset, NullUint64());
9741  }
9742 
9743  /// Provides access to rebroadcastIndicator field.
9747  {
9749 
9750  return ordinary(value, offset, NullUnsignedChar());
9751  }
9752 
9753  /// Provides access to symbolIndex field.
9755  bool symbolIndex(Uint32& value) const
9757  {
9759 
9760  return ordinary(value, offset, NullUint32());
9761  }
9762 
9763  /// Provides access to eventTime field.
9765  bool eventTime(Uint64& value) const
9767  {
9769 
9770  return ordinary(value, offset, NullUint64());
9771  }
9772 
9773  /// Provides access to securityCondition field.
9775  bool
9777  SecurityCondition::Enum& value) const
9779  {
9781 
9782  return enumeration<SecurityCondition>(value, offset, NullChar());
9783  }
9784 
9785  /// Minimal size of message body in bytes.
9788  static
9789  BlockLength
9793  {
9794  return
9795  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9796  22;
9797  }
9798 
9799  /// Size of message body in bytes.
9804  {
9805  return
9806  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9807  minimalBlockLength(version);
9808  }
9809 
9810  /// Minimal variable fields size (when variable-length fields are empty).
9814  static
9815  MessageSize
9818  {
9819  return
9820  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9821  0;
9822  }
9823 
9824  /// \return class name.
9828  static const Char* className()
9829  {
9830  return "BfInstrumentSuspension";
9831  }
9832 
9833  /// FIX message type.
9837  static StrRef fixType()
9839  {
9840  return constructStrRef("BFInstrumentSuspension");
9841  }
9842 
9843  /// \return a human-readable presentation.
9845  std::string toString() const;
9846 
9847 private:
9848  void checkLength(
9849  EncodedLength length, SchemaVersion version) const
9850  {
9851  const EncodedLength minimalRequiredLength =
9852  minimalBlockLength(version) +
9853  MessageHeader::Size +
9854  getMinimalVariableFieldsSize(version);
9855 
9856  checkBinaryLength(
9857  *this, length, minimalRequiredLength);
9858  }
9859 
9860  void checkCompatibility() const
9861  {
9862  assert(TemplateId == templateId());
9863 
9864  checkSchema<Schema>(schemaId(), version());
9865  checkLength(bufferSize(), version());
9866  }
9867 };
9868 
9869 /// Message identifiers and length of message root.
9872 : SbeMessage
9873 {
9874  /// Used template schema.
9876 
9877  /// Message template ID from SBE schema.
9878  enum { TemplateId = 2101 };
9879 
9880  /// Initializes a blank instance.
9882 
9883  /// Creates an instance over the given memory block.
9885  const void* data,
9886  EncodedLength length)
9887  : SbeMessage(data, length)
9888  {
9889  checkCompatibility();
9890  }
9891 
9892  /// Creates an instance over the given SBE message.
9893  explicit
9895  const SbeMessage& message)
9896  : SbeMessage(message)
9897  {
9898  assert(message.valid());
9899 
9900  checkCompatibility();
9901  }
9902 
9903  /// Provides access to lastMDSeqNum field.
9905  bool lastMDSeqNum(Uint64& value) const
9907  {
9909 
9910  return ordinary(value, offset, NullUint64());
9911  }
9912 
9913  /// Provides access to snapshotTime field.
9915  bool snapshotTime(Uint64& value) const
9917  {
9919 
9920  return ordinary(value, offset, NullUint64());
9921  }
9922 
9923  /// Minimal size of message body in bytes.
9926  static
9927  BlockLength
9931  {
9932  return
9933  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9934  16;
9935  }
9936 
9937  /// Size of message body in bytes.
9942  {
9943  return
9944  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9945  minimalBlockLength(version);
9946  }
9947 
9948  /// Minimal variable fields size (when variable-length fields are empty).
9952  static
9953  MessageSize
9956  {
9957  return
9958  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9959  0;
9960  }
9961 
9962  /// \return class name.
9966  static const Char* className()
9967  {
9968  return "StartOfSnapshot";
9969  }
9970 
9971  /// FIX message type.
9975  static StrRef fixType()
9977  {
9978  return constructStrRef("StartOfSnapshot");
9979  }
9980 
9981  /// \return a human-readable presentation.
9983  std::string toString() const;
9984 
9985 private:
9986  void checkLength(
9987  EncodedLength length, SchemaVersion version) const
9988  {
9989  const EncodedLength minimalRequiredLength =
9990  minimalBlockLength(version) +
9991  MessageHeader::Size +
9992  getMinimalVariableFieldsSize(version);
9993 
9994  checkBinaryLength(
9995  *this, length, minimalRequiredLength);
9996  }
9997 
9998  void checkCompatibility() const
9999  {
10000  assert(TemplateId == templateId());
10001 
10002  checkSchema<Schema>(schemaId(), version());
10003  checkLength(bufferSize(), version());
10004  }
10005 };
10006 
10007 /// Message identifiers and length of message root.
10010 : SbeMessage
10011 {
10012  /// Used template schema.
10014 
10015  /// Message template ID from SBE schema.
10016  enum { TemplateId = 2102 };
10017 
10018  /// Initializes a blank instance.
10020 
10021  /// Creates an instance over the given memory block.
10023  const void* data,
10024  EncodedLength length)
10025  : SbeMessage(data, length)
10026  {
10027  checkCompatibility();
10028  }
10029 
10030  /// Creates an instance over the given SBE message.
10031  explicit
10033  const SbeMessage& message)
10034  : SbeMessage(message)
10035  {
10036  assert(message.valid());
10037 
10038  checkCompatibility();
10039  }
10040 
10041  /// Provides access to lastMDSeqNum field.
10043  bool lastMDSeqNum(Uint64& value) const
10045  {
10047 
10048  return ordinary(value, offset, NullUint64());
10049  }
10050 
10051  /// Provides access to snapshotTime field.
10053  bool snapshotTime(Uint64& value) const
10055  {
10057 
10058  return ordinary(value, offset, NullUint64());
10059  }
10060 
10061  /// Minimal size of message body in bytes.
10064  static
10065  BlockLength
10069  {
10070  return
10071  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10072  16;
10073  }
10074 
10075  /// Size of message body in bytes.
10080  {
10081  return
10082  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10083  minimalBlockLength(version);
10084  }
10085 
10086  /// Minimal variable fields size (when variable-length fields are empty).
10090  static
10091  MessageSize
10094  {
10095  return
10096  ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10097  0;
10098  }
10099 
10100  /// \return class name.
10104  static const Char* className()
10105  {
10106  return "EndOfSnapshot";
10107  }
10108 
10109  /// FIX message type.
10113  static StrRef fixType()
10115  {
10116  return constructStrRef("EndOfSnapshot");
10117  }
10118 
10119  /// \return a human-readable presentation.
10121  std::string toString() const;
10122 
10123 private:
10124  void checkLength(
10125  EncodedLength length, SchemaVersion version) const
10126  {
10127  const EncodedLength minimalRequiredLength =
10128  minimalBlockLength(version) +
10129  MessageHeader::Size +
10130  getMinimalVariableFieldsSize(version);
10131 
10132  checkBinaryLength(
10133  *this, length, minimalRequiredLength);
10134  }
10135 
10136  void checkCompatibility() const
10137  {
10138  assert(TemplateId == templateId());
10139 
10140  checkSchema<Schema>(schemaId(), version());
10141  checkLength(bufferSize(), version());
10142  }
10143 };
10144 
10145 
bool maxOrderQuantityContinuous(Uint64 &value) const noexcept
Provides access to maxOrderQuantityContinuous field.
Definition: Messages.h:4142
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:7548
bool efficientMMTSpecialDividendIndicator(EfficientMMTSpecialDividendIndicator::Enum &value) const noexcept
Provides access to efficientMMTSpecialDividendIndicator field.
Definition: Messages.h:8257
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3220
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:4323
bool mMTPreTradeTransparencyWaiverRelatedtoSizeandScale(StrRef &value) const noexcept
Provides access to mMTPreTradeTransparencyWaiverRelatedtoSizeandScale field.
Definition: Messages.h:2316
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:9535
#define ONIXS_EURONEXT_OPTIQMDG_UNUSED
Definition: Compiler.h:211
IntegralConstant< UInt64, 18446744073709551615ULL > NullUInt64
Definition: Fields.h:4733
StrRef mIC() const noexcept
Provides access to mIC field.
Definition: Messages.h:7433
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:2723
MarketDataChangeType::Enum changeType() const noexcept
Provides access to changeType field.
Definition: Messages.h:2559
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2428
bool mMTDuplicativeIndicator(StrRef &value) const noexcept
Provides access to mMTDuplicativeIndicator field.
Definition: Messages.h:2077
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4672
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition: Messages.h:2010
bool confirmedReferenceTime(Uint64 &value) const noexcept
Provides access to confirmedReferenceTime field.
Definition: Messages.h:4887
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:6552
Int64 Int64
Type alias for the Int64_t.
Definition: Fields.h:53
OutrightStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:6319
bool startTimeVwap(Uint32 &value) const noexcept
Provides access to startTimeVwap field.
Definition: Messages.h:2208
bool lowLevel(Int64 &value) const noexcept
Provides access to lowLevel field.
Definition: Messages.h:4947
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:9755
TechnicalNotification(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:462
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:1181
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:6902
bool exDividendDate(Uint16 &value) const noexcept
Provides access to exDividendDate field.
Definition: Messages.h:8867
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:10066
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:3460
SbeGroup< StrategyStandingDatarep1Entry, GroupSizeEncoding, MessageSize > StrategyStandingDatarep1
Repeating group containing StrategyStandingDatarep1Entry entries.
Definition: Messages.h:5188
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:355
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:1737
bool maxOrderAmountCall(Uint64 &value) const noexcept
Provides access to maxOrderAmountCall field.
Definition: Messages.h:4109
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:881
IntegralConstant< Char,-128 > NullChar
Definition: Fields.h:4729
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:6139
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:6695
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:6125
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition: Messages.h:1789
Timetable(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:3099
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:7280
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition: Messages.h:8351
bool openingLevel(Int64 &value) const noexcept
Provides access to openingLevel field.
Definition: Messages.h:4857
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition: Messages.h:4917
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:1150
bool efficientMMTTradingMode(EfficientMMTTradingMode::Enum &value) const noexcept
Provides access to efficientMMTTradingMode field.
Definition: Messages.h:8185
OrdersEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:962
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition: Messages.h:8073
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition: Messages.h:8161
bool statsUpdateValue(Int64 &value) const noexcept
Provides access to statsUpdateValue field.
Definition: Messages.h:4556
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:1471
bool efficientMMTOffBookAutomatedIndicator(EfficientMMTOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to efficientMMTOffBookAutomatedIndicator field.
Definition: Messages.h:8269
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:7647
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:1094
EndOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:10032
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition: Messages.h:9320
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:7569
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:3150
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9928
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition: Messages.h:985
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:277
ApaQuotes(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:7370
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:8586
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition: Messages.h:4045
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition: Messages.h:7657
OutrightRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:6243
NewStatsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:4534
bool dateOfInitialListing(Uint16 &value) const noexcept
Provides access to dateOfInitialListing field.
Definition: Messages.h:8730
StrRef tradingCurrency() const noexcept
Provides access to tradingCurrency field.
Definition: Messages.h:5873
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition: Messages.h:8117
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END
Definition: ABI.h:151
bool dividendPaymentDate(Uint16 &value) const noexcept
Provides access to dividendPaymentDate field.
Definition: Messages.h:8877
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1207
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2411
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition: Messages.h:6380
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition: Messages.h:8425
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:7180
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:1654
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:783
Message identifiers and length of message root.
Definition: Messages.h:4506
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition: Messages.h:3828
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:6330
bool typeOfMarketAdmission(TypeOfMarketAdmission::Enum &value) const noexcept
Provides access to typeOfMarketAdmission field.
Definition: Messages.h:3971
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:7637
bool phaseTime(Uint64 &value) const noexcept
Provides access to phaseTime field.
Definition: Messages.h:2971
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2442
bool instrumentState(InstrumentState::Enum &value) const noexcept
Provides access to instrumentState field.
Definition: Messages.h:2710
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:3387
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition: Messages.h:3500
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9975
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition: Messages.h:6499
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition: Messages.h:9354
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition: Messages.h:5832
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition: Messages.h:1999
bool mMTMarketMechanism(MmtMarketMechanism::Enum &value) const noexcept
Provides access to mMTMarketMechanism field.
Definition: Messages.h:1932
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:5235
#define ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR
Definition: Compiler.h:188
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:4313
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:8544
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition: Messages.h:1865
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:747
bool mMTContributiontoPrice(StrRef &value) const noexcept
Provides access to mMTContributiontoPrice field.
Definition: Messages.h:2033
StrRef cFI() const noexcept
Provides access to cFI field.
Definition: Messages.h:3595
bool motherStockISIN(StrRef &value) const noexcept
Provides access to motherStockISIN field.
Definition: Messages.h:5939
StrRef venue() const noexcept
Provides access to venue field.
Definition: Messages.h:2197
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition: Messages.h:1055
QuoteUpdateType::Enum quoteUpdateType() const noexcept
Provides access to quoteUpdateType field.
Definition: Messages.h:7476
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9060
IntegralConstant< UInt8, 255 > NullUnsignedChar
Null value for an optional UnsignedChar field.
Definition: Fields.h:4677
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition: Messages.h:5652
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2829
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:5215
bool bookState(BookState::Enum &value) const noexcept
Provides access to bookState field.
Definition: Messages.h:2589
bool optionType(OptionType::Enum &value) const noexcept
Provides access to optionType field.
Definition: Messages.h:7776
bool closingPrice(Int64 &value) const noexcept
Provides access to closingPrice field.
Definition: Messages.h:8805
IntegralConstant< UInt16, 65535 > NullUint16
Null value for an optional Uint16 field.
Definition: Fields.h:4689
bool eDSPTickSize(Uint64 &value) const noexcept
Provides access to eDSPTickSize field.
Definition: Messages.h:5960
bool openedClosedFund(OpenedClosedFund::Enum &value) const noexcept
Provides access to openedClosedFund field.
Definition: Messages.h:8751
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:1081
bool coupon(Int64 &value) const noexcept
Provides access to coupon field.
Definition: Messages.h:8784
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition: Messages.h:7411
StrategyStandingDatarep1 strategyStandingDatarep1() const noexcept
Definition: Messages.h:5318
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:7200
IntegralConstant< UInt32, 4294967295 > NullUint32
Null value for an optional Uint32 field.
Definition: Fields.h:4695
bool referencePriceOriginInTradingInterruption(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInTradingInterruption field.
Definition: Messages.h:6049
BfTrade(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:9176
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:7865
bool dividendCurrency(StrRef &value) const noexcept
Provides access to dividendCurrency field.
Definition: Messages.h:8836
GroupSizeEncoding::BlockLength BlockLength
Type to present the length of binary data of the repeating group entry.
Definition: SbeMessage.h:190
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition: Messages.h:6706
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:3173
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition: Messages.h:7220
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition: Messages.h:1767
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition: Messages.h:2134
bool guaranteeIndicator(GuaranteeIndicator::Enum &value) const noexcept
Provides access to guaranteeIndicator field.
Definition: Messages.h:3699
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:6949
bool strategyAuthorized(StrategyAuthorized &value) const noexcept
Provides access to strategyAuthorized field.
Definition: Messages.h:5514
bool taxDescriptionAttachingToADividend(TaxDescriptionAttachingtoaDividend::Enum &value) const noexcept
Provides access to taxDescriptionAttachingToADividend field.
Definition: Messages.h:8888
Message identifiers and length of message root.
Definition: Messages.h:934
IntegralConstant< Int8,-128 > NullInt8
Null value for an optional Int8 field.
Definition: Fields.h:4683
StrRef instrumentName() const noexcept
Provides access to instrumentName field.
Definition: Messages.h:3511
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition: Messages.h:8340
NotUsedGroup1Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1640
bool currency(StrRef &value) const noexcept
Provides access to currency field.
Definition: Messages.h:8719
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition: Messages.h:5493
SbeGroup< NewStatsEntry, GroupSizeEncoding, MessageSize > NewStats
Repeating group containing NewStatsEntry entries.
Definition: Messages.h:4604
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:7466
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition: Messages.h:1887
bool legLastPx(Int64 &value) const noexcept
Provides access to legLastPx field.
Definition: Messages.h:7085
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition: Messages.h:3333
bool liquidationTime(Uint64 &value) const noexcept
Provides access to liquidationTime field.
Definition: Messages.h:4977
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition: Messages.h:3012
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:573
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition: Messages.h:708
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:207
Message identifiers and length of message root.
Definition: Messages.h:172
bool liquidationLevel(Int64 &value) const noexcept
Provides access to liquidationLevel field.
Definition: Messages.h:4967
#define ONIXS_EURONEXT_OPTIQMDG_NOTHROW
Definition: Compiler.h:186
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:104
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4438
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition: Messages.h:3916
bool derivativesInstrumentType(DerivativesInstrumentType::Enum &value) const noexcept
Provides access to derivativesInstrumentType field.
Definition: Messages.h:6465
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:6600
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition: Messages.h:8361
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:69
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition: Messages.h:9365
PackageComponentsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:7053
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition: Messages.h:7796
Message identifiers and length of message root.
Definition: Messages.h:7933
bool referencePriceOriginInOpeningCall(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInOpeningCall field.
Definition: Messages.h:6025
bool nAVBidPrice(Int64 &value) const noexcept
Provides access to nAVBidPrice field.
Definition: Messages.h:9597
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:4595
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:7998
bool maxOrderQuantityCall(Uint64 &value) const noexcept
Provides access to maxOrderQuantityCall field.
Definition: Messages.h:4131
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:9735
MmProtections mMProtections() const noexcept
Provides access to mMProtections field.
Definition: Messages.h:5894
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:6836
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:678
bool dynamicCollarLogic(DynamicCollarLogic::Enum &value) const noexcept
Provides access to dynamicCollarLogic field.
Definition: Messages.h:5526
Message identifiers and length of message root.
Definition: Messages.h:5070
bool numTradedInstruments(Uint16 &value) const noexcept
Provides access to numTradedInstruments field.
Definition: Messages.h:4393
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition: Messages.h:1799
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2841
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition: Messages.h:1876
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition: Messages.h:2666
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition: Messages.h:6423
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9837
bool messagePriceNotation(MessagePriceNotation::Enum &value) const noexcept
Provides access to messagePriceNotation field.
Definition: Messages.h:2261
MarketUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:772
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:5573
PhaseId::Enum phaseId() const noexcept
Provides access to phaseId field.
Definition: Messages.h:2981
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition: Messages.h:7210
IndexLevelType::Enum indexLevelType() const noexcept
Provides access to indexLevelType field.
Definition: Messages.h:4403
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9086
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition: Messages.h:8941
Message identifiers and length of message root.
Definition: Messages.h:448
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:4651
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9802
bool lastTradingDate(Uint16 &value) const noexcept
Provides access to lastTradingDate field.
Definition: Messages.h:6433
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition: Messages.h:1352
bool priceQualifier(PriceQualifier::Enum &value) const noexcept
Provides access to priceQualifier field.
Definition: Messages.h:1385
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition: Messages.h:6413
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:3061
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition: Messages.h:7807
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:4817
TechnicalNotificationType::Enum technicalNotificationType() const noexcept
Provides access to technicalNotificationType field.
Definition: Messages.h:494
#define ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
Definition: ABI.h:94
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4684
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition: Messages.h:9309
bool ratioMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to ratioMultiplierDecimals field.
Definition: Messages.h:9037
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition: Messages.h:7723
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:734
bool mMTContingentTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTContingentTransactionIndicator field.
Definition: Messages.h:2340
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1524
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition: Messages.h:3752
InterestPaymentDateRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:8548
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:230
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:6923
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition: Messages.h:1015
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition: Messages.h:5863
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition: Messages.h:4383
bool marketModel(MarketModel::Enum &value) const noexcept
Provides access to marketModel field.
Definition: Messages.h:3343
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition: Messages.h:9299
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition: Messages.h:1025
bool efficientMMTTransactionCategory(EfficientMMTTransactionCategory::Enum &value) const noexcept
Provides access to efficientMMTTransactionCategory field.
Definition: Messages.h:8197
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition: Messages.h:2177
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:2786
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition: Messages.h:8019
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition: Messages.h:8996
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition: Messages.h:5970
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:803
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition: Messages.h:6776
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:9238
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition: Messages.h:5693
RealTimeIndex(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:4302
SbeGroup< NotUsedGroup1Entry, GroupSizeEncoding, MessageSize > NotUsedGroup1
Repeating group containing NotUsedGroup1Entry entries.
Definition: Messages.h:1690
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:1481
ApaQuotes(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:7380
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:5016
Operations over a repeating group instance.
Definition: SbeMessage.h:186
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:1140
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition: Messages.h:3817
bool nominalCurrency(StrRef &value) const noexcept
Provides access to nominalCurrency field.
Definition: Messages.h:4004
StrRef currency() const noexcept
Provides access to currency field.
Definition: Messages.h:7444
Message identifiers and length of message root.
Definition: Messages.h:6655
bool interestPaymentDate(Uint16 &value) const noexcept
Provides access to interestPaymentDate field.
Definition: Messages.h:8560
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition: Messages.h:8030
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:7049
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:4837
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:2806
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:242
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:1130
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition: Messages.h:5682
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition: Messages.h:3616
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:1305
bool efficientMMTNegotiationIndicator(EfficientMMTNegotiationIndicator::Enum &value) const noexcept
Provides access to efficientMMTNegotiationIndicator field.
Definition: Messages.h:8209
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition: Messages.h:6509
bool lowTime(Uint64 &value) const noexcept
Provides access to lowTime field.
Definition: Messages.h:4957
bool grossOfCDSCIndicator(GrossofCDSCIndicator::Enum &value) const noexcept
Provides access to grossOfCDSCIndicator field.
Definition: Messages.h:8773
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:4353
bool closingReferenceLevel(Int64 &value) const noexcept
Provides access to closingReferenceLevel field.
Definition: Messages.h:4897
bool mMTPublicationModeIlliquid(StrRef &value) const noexcept
Provides access to mMTPublicationModeIlliquid field.
Definition: Messages.h:2352
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition: Messages.h:7075
ApaStandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:7616
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition: Messages.h:6756
bool minimumAmount(Int64 &value) const noexcept
Provides access to minimumAmount field.
Definition: Messages.h:8964
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:2579
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition: Messages.h:6391
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition: Messages.h:8665
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:3110
#define ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
Definition: Compiler.h:189
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition: Messages.h:6766
BfInstrumentSuspension(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:9714
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:8655
HealthStatus(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:324
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:8635
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:7988
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition: Messages.h:9776
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:9217
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:4582
bool offerPrice(Int64 &value) const noexcept
Provides access to offerPrice field.
Definition: Messages.h:9289
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition: Messages.h:3140
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition: Messages.h:8414
bool strikeCurrency(StrRef &value) const noexcept
Provides access to strikeCurrency field.
Definition: Messages.h:3938
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:846
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition: Messages.h:7818
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition: Messages.h:5473
UpdatesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:655
bool mMTAlgorithmicIndicator(StrRef &value) const noexcept
Provides access to mMTAlgorithmicIndicator field.
Definition: Messages.h:2044
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition: Messages.h:5747
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:1425
bool grossDividendPayablePerUnit(Int64 &value) const noexcept
Provides access to grossDividendPayablePerUnit field.
Definition: Messages.h:8826
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:92
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:559
bool tradingSide(TradingSide::Enum &value) const noexcept
Provides access to tradingSide field.
Definition: Messages.h:2633
bool indexLevel(Int64 &value) const noexcept
Provides access to indexLevel field.
Definition: Messages.h:4363
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition: Messages.h:8139
bool legPrice(Int64 &value) const noexcept
Provides access to legPrice field.
Definition: Messages.h:5120
StrRef countryOfExchange() const noexcept
Provides access to countryOfExchange field.
Definition: Messages.h:5799
bool shareAmountInIssue(Int64 &value) const noexcept
Provides access to shareAmountInIssue field.
Definition: Messages.h:8740
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:834
ContractEMMPropertiesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5461
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition: Messages.h:1898
Message identifiers and length of message root.
Definition: Messages.h:310
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition: Messages.h:9566
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition: Messages.h:3034
Message identifiers and length of message root.
Definition: Messages.h:10008
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition: Messages.h:9227
SbeGroup< ContractEMMPropertiesEntry, GroupSizeEncoding, MessageSize > ContractEMMProperties
Repeating group containing ContractEMMPropertiesEntry entries.
Definition: Messages.h:5595
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9646
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:5378
bool venueofPublication(StrRef &value) const noexcept
Provides access to venueofPublication field.
Definition: Messages.h:2376
bool instrumentTradingCode(StrRef &value) const noexcept
Provides access to instrumentTradingCode field.
Definition: Messages.h:3522
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition: Messages.h:6726
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition: Messages.h:2228
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition: Messages.h:5276
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:1332
bool mMTPublicationModeSizeSpecific(StrRef &value) const noexcept
Provides access to mMTPublicationModeSizeSpecific field.
Definition: Messages.h:2364
bool priceIndexLevelDecimals(UnsignedChar &value) const noexcept
Provides access to priceIndexLevelDecimals field.
Definition: Messages.h:9007
bool underlyingDerivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to underlyingDerivativesInstrumentTradingCode field.
Definition: Messages.h:6488
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:10078
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition: Messages.h:2991
MarketStatusChange(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:2775
bool maximumDecimalsInQuantity(UnsignedChar &value) const noexcept
Provides access to maximumDecimalsInQuantity field.
Definition: Messages.h:3763
bool mMTOffBookAutomatedIndicator(MmtOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to mMTOffBookAutomatedIndicator field.
Definition: Messages.h:2022
SbeGroup< OutrightRepEntry, GroupSizeEncoding, MessageSize > OutrightRep
Repeating group containing OutrightRepEntry entries.
Definition: Messages.h:6303
BfInstrumentSuspension(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:9724
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition: Messages.h:5266
#define ONIXS_EURONEXT_OPTIQMDG_NODISCARD
Definition: Compiler.h:195
#define ONIXS_EURONEXT_OPTIQMDG_DEFAULT
Definition: Compiler.h:212
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition: Messages.h:1977
InterestPaymentDateRep interestPaymentDateRep() const noexcept
Definition: Messages.h:9047
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition: Messages.h:7497
Message identifiers and length of message root.
Definition: Messages.h:7025
bool nextMeeting(StrRef &value) const noexcept
Provides access to nextMeeting field.
Definition: Messages.h:8899
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition: Messages.h:9269
bool mIC(StrRef &value) const noexcept
Provides access to mIC field.
Definition: Messages.h:8815
StrRef lEICode() const noexcept
Provides access to lEICode field.
Definition: Messages.h:7455
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:6255
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:5357
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition: Messages.h:7679
StrategyStandingDatarep1Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:5098
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition: Messages.h:9555
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:1636
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition: Messages.h:995
bool lastAdjustedClosingPrice(Int64 &value) const noexcept
Provides access to lastAdjustedClosingPrice field.
Definition: Messages.h:3732
bool depositaryList(StrRef &value) const noexcept
Provides access to depositaryList field.
Definition: Messages.h:3666
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition: Messages.h:7840
bool issueDate(Uint16 &value) const noexcept
Provides access to issueDate field.
Definition: Messages.h:8920
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:3470
bool pctgOfCapitalization(Uint64 &value) const noexcept
Provides access to pctgOfCapitalization field.
Definition: Messages.h:4373
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition: Messages.h:8062
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:3297
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:4641
PricesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1309
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:2796
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9954
bool mMTPortfolioTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTPortfolioTransactionIndicator field.
Definition: Messages.h:2328
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:1412
bool efficientMMTDuplicativeIndicator(EfficientMMTDuplicativeIndicator::Enum &value) const noexcept
Provides access to efficientMMTDuplicativeIndicator field.
Definition: Messages.h:8329
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:146
bool notionalAmountTraded(Int64 &value) const noexcept
Provides access to notionalAmountTraded field.
Definition: Messages.h:9376
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition: Messages.h:3742
bool iSINCode(StrRef &value) const noexcept
Provides access to iSINCode field.
Definition: Messages.h:8675
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9816
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:1727
TechnicalNotification(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:472
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:1491
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition: Messages.h:8106
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4426
LegBuyorSell::Enum legBuySell() const noexcept
Provides access to legBuySell field.
Definition: Messages.h:5140
bool blockTradeCode(BlockTradeCode::Enum &value) const noexcept
Provides access to blockTradeCode field.
Definition: Messages.h:2123
bool dividendRecordDate(Uint16 &value) const noexcept
Provides access to dividendRecordDate field.
Definition: Messages.h:8847
bool numberInstrumentCirculating(Uint64 &value) const noexcept
Provides access to numberInstrumentCirculating field.
Definition: Messages.h:3884
StartOfSnapshot(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:9884
bool contractEventDate(Uint16 &value) const noexcept
Provides access to contractEventDate field.
Definition: Messages.h:5672
bool longInstrumentName(StrRef &value) const noexcept
Provides access to longInstrumentName field.
Definition: Messages.h:8708
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition: Messages.h:7701
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:6882
bool efficientMMTPublicationMode(EfficientMMTPublicationMode::Enum &value) const noexcept
Provides access to efficientMMTPublicationMode field.
Definition: Messages.h:8305
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:6565
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition: Messages.h:5821
IndexPriceCode::Enum indexPriceCode() const noexcept
Provides access to indexPriceCode field.
Definition: Messages.h:4413
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition: Messages.h:6402
bool sessionTradingDay(Uint16 &value) const noexcept
Provides access to sessionTradingDay field.
Definition: Messages.h:217
Message identifiers and length of message root.
Definition: Messages.h:34
SbeGroup< TimetablesEntry, GroupSizeEncoding, MessageSize > Timetables
Repeating group containing TimetablesEntry entries.
Definition: Messages.h:3083
bool referencePriceOriginInContinuous(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInContinuous field.
Definition: Messages.h:6037
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:7107
Message identifiers and length of message root.
Definition: Messages.h:9480
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition: Messages.h:5297
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition: Messages.h:3364
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:1067
bool settlementDelay(StrRef &value) const noexcept
Provides access to settlementDelay field.
Definition: Messages.h:3927
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition: Messages.h:1778
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:1461
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition: Messages.h:3565
bool mMTModificationIndicator(StrRef &value) const noexcept
Provides access to mMTModificationIndicator field.
Definition: Messages.h:1988
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:7522
bool statusReason(StatusReason::Enum &value) const noexcept
Provides access to statusReason field.
Definition: Messages.h:2600
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition: Messages.h:3850
bool efficientMMTBenchmarkIndicator(EfficientMMTBenchmarkIndicator::Enum &value) const noexcept
Provides access to efficientMMTBenchmarkIndicator field.
Definition: Messages.h:8245
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition: Messages.h:6716
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4698
ApaFullTradeInformation(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:7947
bool mMTPostTradeDeferral(StrRef &value) const noexcept
Provides access to mMTPostTradeDeferral field.
Definition: Messages.h:2066
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition: Messages.h:7422
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:6809
bool strikePriceDecimalsRatio(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimalsRatio field.
Definition: Messages.h:5884
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition: Messages.h:1005
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2855
bool derivativesMarketModel(DerivativesMarketModel::Enum &value) const noexcept
Provides access to derivativesMarketModel field.
Definition: Messages.h:6003
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:7121
LisPackageStructure(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:7159
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition: Messages.h:7690
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition: Messages.h:1342
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:8465
bool missingPrice(StrRef &value) const noexcept
Provides access to missingPrice field.
Definition: Messages.h:2304
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition: Messages.h:5503
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:3074
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition: Messages.h:9331
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:5559
bool tradingCurrencyIndicator(TradingCurrencyIndicator::Enum &value) const noexcept
Provides access to tradingCurrencyIndicator field.
Definition: Messages.h:3861
bool darkEligibility(UnsignedChar &value) const noexcept
Provides access to darkEligibility field.
Definition: Messages.h:3626
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:6112
bool evaluatedPrice(Int64 &value) const noexcept
Provides access to evaluatedPrice field.
Definition: Messages.h:2250
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:7190
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition: Messages.h:3544
StartOfDay(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:48
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:4530
bool underlyingSubtype(UnderlyingSubtype::Enum &value) const noexcept
Provides access to underlyingSubtype field.
Definition: Messages.h:5928
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition: Messages.h:6746
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:4807
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:5225
Message identifiers and length of message root.
Definition: Messages.h:1281
bool lastNAVPrice(Int64 &value) const noexcept
Provides access to lastNAVPrice field.
Definition: Messages.h:8762
bool taxCode(TaxCode::Enum &value) const noexcept
Provides access to taxCode field.
Definition: Messages.h:3949
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition: Messages.h:9027
Bfnav(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:9504
bool highTime(Uint64 &value) const noexcept
Provides access to highTime field.
Definition: Messages.h:4937
SbeGroup< PackageComponentsEntry, GroupSizeEncoding, MessageSize > PackageComponents
Repeating group containing PackageComponentsEntry entries.
Definition: Messages.h:7143
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition: Messages.h:7231
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:1717
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9632
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:547
MessageSize BlockLength
Length of the message body representing a block of fixed-length fields.
Definition: SbeMessage.h:806
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2876
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:7853
bool tradingPolicy(TradingPolicy::Enum &value) const noexcept
Provides access to tradingPolicy field.
Definition: Messages.h:5981
bool nAVOfferPrice(Int64 &value) const noexcept
Provides access to nAVOfferPrice field.
Definition: Messages.h:9607
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition: Messages.h:6360
UInt8 UnsignedChar
Type alias for the Unsigned_char.
Definition: Fields.h:29
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9667
IntegralConstant< Int64,-9223372036854775807LL-1 > NullInt64
Null value for an optional Int64 field.
Definition: Fields.h:4713
bool strikeCurrencyIndicator(StrikeCurrencyIndicator::Enum &value) const noexcept
Provides access to strikeCurrencyIndicator field.
Definition: Messages.h:3873
bool expiryCycleType(ExpiryCycleType::Enum &value) const noexcept
Provides access to expiryCycleType field.
Definition: Messages.h:6477
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9400
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:5343
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:9207
SbeGroup< InterestPaymentDateRepEntry, GroupSizeEncoding, MessageSize > InterestPaymentDateRep
Repeating group containing InterestPaymentDateRepEntry entries.
Definition: Messages.h:8608
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition: Messages.h:9248
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:9525
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:2542
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition: Messages.h:3606
StrRef instrumentGroupCode() const noexcept
Provides access to instrumentGroupCode field.
Definition: Messages.h:3533
bool mMTNegotiationIndicator(StrRef &value) const noexcept
Provides access to mMTNegotiationIndicator field.
Definition: Messages.h:1966
PricingAlgorithm::Enum pricingAlgorithm() const noexcept
Provides access to pricingAlgorithm field.
Definition: Messages.h:6080
bool legSymbolIndex(Uint32 &value) const noexcept
Provides access to legSymbolIndex field.
Definition: Messages.h:5110
Statistics(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:4620
EndOfDay(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:196
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:4333
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition: Messages.h:9258
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition: Messages.h:8008
UnderlyingType::Enum underlyingType() const noexcept
Provides access to underlyingType field.
Definition: Messages.h:5727
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1559
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:6281
SbeGroup< PricesEntry, GroupSizeEncoding, MessageSize > Prices
Repeating group containing PricesEntry entries.
Definition: Messages.h:1434
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:9197
Message identifiers and length of message root.
Definition: Messages.h:9162
StartOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:9894
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition: Messages.h:3490
bool mICList(StrRef &value) const noexcept
Provides access to mICList field.
Definition: Messages.h:3784
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition: Messages.h:8930
bool bidPrice(Int64 &value) const noexcept
Provides access to bidPrice field.
Definition: Messages.h:9279
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition: Messages.h:2145
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition: Messages.h:3839
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition: Messages.h:9386
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:5331
SbeGroup< EmmPatternRepEntry, GroupSizeEncoding, MessageSize > EmmPatternRep
Repeating group containing EmmPatternRepEntry entries.
Definition: Messages.h:3423
bool sessionTradingDay(Uint16 &value) const noexcept
Provides access to sessionTradingDay field.
Definition: Messages.h:79
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:345
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:6340
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:8486
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:4847
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:7301
bool mMTPublicationMode(StrRef &value) const noexcept
Provides access to mMTPublicationMode field.
Definition: Messages.h:2055
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4719
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition: Messages.h:3904
bool countryOfExchange(StrRef &value) const noexcept
Provides access to countryOfExchange field.
Definition: Messages.h:3795
MessageSize EncodedLength
Length of the message binary data.
Definition: SbeMessage.h:803
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition: Messages.h:2611
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:4568
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:6872
bool underlyingIndexName(StrRef &value) const noexcept
Provides access to underlyingIndexName field.
Definition: Messages.h:7754
bool confirmedReferenceLevel(Int64 &value) const noexcept
Provides access to confirmedReferenceLevel field.
Definition: Messages.h:4877
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1193
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition: Messages.h:8794
bool transparencyIndicator(TransparencyIndicator::Enum &value) const noexcept
Provides access to transparencyIndicator field.
Definition: Messages.h:2156
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:7391
bool settlementDate(Uint16 &value) const noexcept
Provides access to settlementDate field.
Definition: Messages.h:2272
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:594
Int8 Int8
Type alias for the Int8_t.
Definition: Fields.h:33
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:7254
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:6239
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1228
bool iCB(StrRef &value) const noexcept
Provides access to iCB field.
Definition: Messages.h:3710
OrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1119
bool underlyingIndexTerm(StrRef &value) const noexcept
Provides access to underlyingIndexTerm field.
Definition: Messages.h:7765
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition: Messages.h:5757
LongOrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:6861
constexpr StrRef constructStrRef(const char(&value)[Size]) noexcept
Definition: StrRef.h:415
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:7401
Message identifiers and length of message root.
Definition: Messages.h:2518
ContractTradingType::Enum contractTradingType() const noexcept
Provides access to contractTradingType field.
Definition: Messages.h:5905
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:813
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3199
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition: Messages.h:8040
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition: Messages.h:8051
OrdersEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:6683
bool expirationDate(Uint16 &value) const noexcept
Provides access to expirationDate field.
Definition: Messages.h:6530
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition: Messages.h:10043
MarketStatesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2546
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:1398
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:5002
ContractStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:5611
bool paymentFrequency(PaymentFrequency::Enum &value) const noexcept
Provides access to paymentFrequency field.
Definition: Messages.h:8953
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition: Messages.h:7743
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:6970
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2463
MarketDataUpdateType::Enum updateType() const noexcept
Provides access to updateType field.
Definition: Messages.h:668
Message identifiers and length of message root.
Definition: Messages.h:627
Message identifiers and length of message root.
Definition: Messages.h:9870
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition: Messages.h:9905
Message identifiers and length of message root.
Definition: Messages.h:7602
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4175
bool postTradeDeferralFlags(StrRef &value) const noexcept
Provides access to postTradeDeferralFlags field.
Definition: Messages.h:2388
bool longIssuerName(StrRef &value) const noexcept
Provides access to longIssuerName field.
Definition: Messages.h:8697
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4190
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition: Messages.h:9545
bool legLastQty(Uint64 &value) const noexcept
Provides access to legLastQty field.
Definition: Messages.h:7095
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition: Messages.h:3585
bool closingReferenceTime(Uint64 &value) const noexcept
Provides access to closingReferenceTime field.
Definition: Messages.h:4907
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition: Messages.h:1045
IntegralConstant< UInt64, 18446744073709551615ULL > NullUint64
Null value for an optional Uint64 field.
Definition: Fields.h:4701
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:860
StrRef firmId() const noexcept
Provides access to firmID field.
Definition: Messages.h:6786
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9620
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9940
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:7968
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:5457
UInt64 Uint64
Type alias for the Uint64_t.
Definition: Fields.h:45
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition: Messages.h:8371
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:4631
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:3414
bool retransmissionEndTime(Uint64 &value) const noexcept
Provides access to retransmissionEndTime field.
Definition: Messages.h:524
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:651
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition: Messages.h:1103
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1538
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition: Messages.h:7733
bool longMnemonic(StrRef &value) const noexcept
Provides access to longMnemonic field.
Definition: Messages.h:4097
RealTimeIndex(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:4292
bool repoIndicator(RepoIndicator::Enum &value) const noexcept
Provides access to repoIndicator field.
Definition: Messages.h:3983
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:2737
bool nAVPrice(Int64 &value) const noexcept
Provides access to nAVPrice field.
Definition: Messages.h:9577
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition: SchemaTraits.h:30
StrRef mifidPrice() const noexcept
Provides access to mifidPrice field.
Definition: Messages.h:7486
HealthStatus(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:334
bool efficientMMTMarketMechanism(EfficientMMTMarketMechanism::Enum &value) const noexcept
Provides access to efficientMMTMarketMechanism field.
Definition: Messages.h:8173
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9790
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition: Messages.h:8392
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:1160
Message identifiers and length of message root.
Definition: Messages.h:6215
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition: Messages.h:5662
bool issuePrice(Int64 &value) const noexcept
Provides access to issuePrice field.
Definition: Messages.h:3994
StrRef productCode() const noexcept
Provides access to productCode field.
Definition: Messages.h:5810
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition: Messages.h:8084
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition: Messages.h:2239
bool underlyingExpiry(Uint32 &value) const noexcept
Provides access to underlyingExpiry field.
Definition: Messages.h:5843
Message identifiers and length of message root.
Definition: Messages.h:4278
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:1512
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:3313
AccountType::Enum accountType() const noexcept
Provides access to accountType field.
Definition: Messages.h:6797
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:1757
UInt32 Uint32
Type alias for the Uint32_t.
Definition: Fields.h:41
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:6823
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition: Messages.h:5737
Message identifiers and length of message root.
Definition: Messages.h:5433
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:5166
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition: Messages.h:3575
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:7978
bool thresholdLISPostTradeEOD(Uint64 &value) const noexcept
Provides access to thresholdLISPostTradeEOD field.
Definition: Messages.h:4087
bool numberOfOrders(Uint16 &value) const noexcept
Provides access to numberOfOrders field.
Definition: Messages.h:688
Message identifiers and length of message root.
Definition: Messages.h:3273
bool endTimeVwap(Uint32 &value) const noexcept
Provides access to endTimeVwap field.
Definition: Messages.h:2218
bool collarMaxUnhaltNb(UnsignedChar &value) const noexcept
Provides access to collarMaxUnhaltNb field.
Definition: Messages.h:5537
bool issuePriceDecimals(UnsignedChar &value) const noexcept
Provides access to issuePriceDecimals field.
Definition: Messages.h:4015
bool thresholdLISPostTrade60mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade60mn field.
Definition: Messages.h:4067
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:504
StrRef mIC() const noexcept
Provides access to mIC field.
Definition: Messages.h:5788
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:368
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition: Messages.h:5777
EndOfSnapshot(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:10022
bool grossDividendInEuros(Int64 &value) const noexcept
Provides access to grossDividendInEuros field.
Definition: Messages.h:8910
EndOfDay(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:186
bool repoSettlementDate(Uint16 &value) const noexcept
Provides access to repoSettlementDate field.
Definition: Messages.h:2282
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition: Messages.h:1920
EmmPatternRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3301
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition: Messages.h:10053
bool efficientMMTModificationIndicator(EfficientMMTModificationIndicator::Enum &value) const noexcept
Provides access to efficientMMTModificationIndicator field.
Definition: Messages.h:8233
bool efficientMMTContributiontoPrice(EfficientMMTContributiontoPrice::Enum &value) const noexcept
Provides access to efficientMMTContributiontoPrice field.
Definition: Messages.h:8281
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition: Messages.h:9915
bool efficientMMTPostTradeDeferral(EfficientMMTPostTradeDeferral::Enum &value) const noexcept
Provides access to efficientMMTPostTradeDeferral field.
Definition: Messages.h:8317
Message identifiers and length of message root.
Definition: Messages.h:1612
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:6579
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:5642
ApaFullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:7957
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4204
bool mMTTransactionCategory(StrRef &value) const noexcept
Provides access to mMTTransactionCategory field.
Definition: Messages.h:1955
bool dateOfLastTrade(Uint16 &value) const noexcept
Provides access to dateOfLastTrade field.
Definition: Messages.h:3656
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:1668
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition: Messages.h:5287
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:6160
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition: Messages.h:2688
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition: Messages.h:5130
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4225
StartOfDay(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:58
InstrumentCategory::Enum instrumentCategory() const noexcept
Provides access to instrumentCategory field.
Definition: Messages.h:8974
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition: Messages.h:2167
bool parValue(Uint64 &value) const noexcept
Provides access to parValue field.
Definition: Messages.h:3894
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:6892
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:10113
StrRef mIC() const noexcept
Provides access to mIC field.
Definition: Messages.h:3773
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition: Messages.h:8150
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition: Messages.h:3721
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition: Messages.h:9343
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:3047
MarketDataPriceType::Enum priceType() const noexcept
Provides access to priceType field.
Definition: Messages.h:1322
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:256
ContractEMMProperties contractEMMProperties() const noexcept
Definition: Messages.h:6101
StatsUpdateType::Enum statsUpdateType() const noexcept
Provides access to statsUpdateType field.
Definition: Messages.h:4546
UInt16 MessageSize
Message length type.
Definition: Aliases.h:29
TradeQualifier tradeQualifier() const noexcept
Provides access to tradeQualifier field.
Definition: Messages.h:2088
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:7900
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition: Messages.h:1843
Message identifiers and length of message root.
Definition: Messages.h:2931
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:8438
bool daysToExpiry(Uint16 &value) const noexcept
Provides access to daysToExpiry field.
Definition: Messages.h:6443
OrderTypeRules orderTypeRules() const noexcept
Provides access to orderTypeRules field.
Definition: Messages.h:5853
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:5632
Session::Enum session() const noexcept
Provides access to session field.
Definition: Messages.h:3023
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition: Messages.h:4025
StrategyStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:5204
bool settlementTickSize(Uint64 &value) const noexcept
Provides access to settlementTickSize field.
Definition: Messages.h:5950
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9412
bool maxOrderAmountContinuous(Uint64 &value) const noexcept
Provides access to maxOrderAmountContinuous field.
Definition: Messages.h:4120
IndexSummary(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:4786
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:8451
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:958
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:534
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:415
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition: Messages.h:6090
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:394
bool priceLimits(PriceLimits::Enum &value) const noexcept
Provides access to priceLimits field.
Definition: Messages.h:2643
StrRef venue() const noexcept
Provides access to venue field.
Definition: Messages.h:8381
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:5245
bool mnemonic(StrRef &value) const noexcept
Provides access to mnemonic field.
Definition: Messages.h:3806
bool typeOfCorporateEvent(StrRef &value) const noexcept
Provides access to typeOfCorporateEvent field.
Definition: Messages.h:3959
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition: Messages.h:7668
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition: Messages.h:3353
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition: Messages.h:1810
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:5037
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:8645
StandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:3439
TradingPeriod::Enum tradingPeriod() const noexcept
Provides access to tradingPeriod field.
Definition: Messages.h:3001
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition: Messages.h:5483
Message identifiers and length of message root.
Definition: Messages.h:4772
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition: Messages.h:4827
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:118
bool transactionType(TransactionType::Enum &value) const noexcept
Provides access to transactionType field.
Definition: Messages.h:2099
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:9765
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:7170
FullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1706
bool iCBCode(StrRef &value) const noexcept
Provides access to iCBCode field.
Definition: Messages.h:4056
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:6267
SbeGroup< MarketStatesEntry, GroupSizeEncoding, MessageSize > MarketStates
Repeating group containing MarketStatesEntry entries.
Definition: Messages.h:2759
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition: Messages.h:2187
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition: Messages.h:9017
TimetablesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2959
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition: Messages.h:8128
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:5622
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition: Messages.h:3555
bool efficientMMTAgencyCrossTradeIndicator(EfficientMMTAgencyCrossTradeIndicator::Enum &value) const noexcept
Provides access to efficientMMTAgencyCrossTradeIndicator field.
Definition: Messages.h:8221
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:6350
bool longTradeReference(StrRef &value) const noexcept
Provides access to longTradeReference field.
Definition: Messages.h:8403
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition: Messages.h:7508
ApaStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:7626
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:793
bool efficientMMTAlgorithmicIndicator(EfficientMMTAlgorithmicIndicator::Enum &value) const noexcept
Provides access to efficientMMTAlgorithmicIndicator field.
Definition: Messages.h:8293
bool darkLISThreshold(Uint64 &value) const noexcept
Provides access to darkLISThreshold field.
Definition: Messages.h:3636
Session::Enum session() const noexcept
Provides access to session field.
Definition: Messages.h:2677
bool liquidInstrumentIndicator(UnsignedChar &value) const noexcept
Provides access to liquidInstrumentIndicator field.
Definition: Messages.h:4035
Message identifiers and length of message root.
Definition: Messages.h:7356
bool secondNotionalCurrency(StrRef &value) const noexcept
Provides access to secondNotionalCurrency field.
Definition: Messages.h:7712
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3185
bool derivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition: Messages.h:6453
bool quoteSpreadMultiplier(QuoteSpreadMultiplier::Enum &value) const noexcept
Provides access to quoteSpreadMultiplier field.
Definition: Messages.h:2654
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4473
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:7266
bool anonymous(Anonymous::Enum &value) const noexcept
Provides access to anonymous field.
Definition: Messages.h:3375
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:6679
bool darkMinQuantity(Uint32 &value) const noexcept
Provides access to darkMinQuantity field.
Definition: Messages.h:3646
bool imbalanceQtySide(ImbalanceQuantitySide::Enum &value) const noexcept
Provides access to imbalanceQtySide field.
Definition: Messages.h:1373
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition: Messages.h:7786
StrRef contractName() const noexcept
Provides access to contractName field.
Definition: Messages.h:5704
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:7534
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition: Messages.h:1854
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition: Messages.h:1821
UInt16 Uint16
Type alias for the Uint16_t.
Definition: Fields.h:37
#define ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
Definition: ABI.h:98
bool referenceSpreadTableId(Uint16 &value) const noexcept
Provides access to referenceSpreadTableID field.
Definition: Messages.h:5992
IndexSummary(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:4796
bool thresholdLISPostTrade120mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade120mn field.
Definition: Messages.h:4077
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition: Messages.h:6370
bool mIFIdIILiquidFlag(UnsignedChar &value) const noexcept
Provides access to mIFIDIILiquidFlag field.
Definition: Messages.h:6070
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition: Messages.h:5767
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:4343
bool contractType(ContractType::Enum &value) const noexcept
Provides access to contractType field.
Definition: Messages.h:5716
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:3120
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition: Messages.h:3323
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition: Messages.h:2292
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition: Messages.h:6519
bool imbalanceQty(Uint64 &value) const noexcept
Provides access to imbalanceQty field.
Definition: Messages.h:1362
bool dividendRate(Uint64 &value) const noexcept
Provides access to dividendRate field.
Definition: Messages.h:8857
bool effectiveDateIndicator(EffectiveDateIndicator::Enum &value) const noexcept
Provides access to effectiveDateIndicator field.
Definition: Messages.h:2111
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:9587
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition: Messages.h:8985
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition: Messages.h:698
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition: Messages.h:5307
bool openingTime(Uint64 &value) const noexcept
Provides access to openingTime field.
Definition: Messages.h:4867
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition: Messages.h:1909
bool retransmissionStartTime(Uint64 &value) const noexcept
Provides access to retransmissionStartTime field.
Definition: Messages.h:514
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:7879
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition: Messages.h:1944
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition: Messages.h:3677
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4452
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition: Messages.h:1832
BfTrade(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:9186
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition: Messages.h:3480
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition: Messages.h:6845
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition: Messages.h:1035
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition: Messages.h:6736
bool sEDOLCode(StrRef &value) const noexcept
Provides access to sEDOLCode field.
Definition: Messages.h:8686
SbeGroup< UpdatesEntry, GroupSizeEncoding, MessageSize > Updates
Repeating group containing UpdatesEntry entries.
Definition: Messages.h:756
Message identifiers and length of message root.
Definition: Messages.h:9700
bool collarExpansionFactor(UnsignedChar &value) const noexcept
Provides access to collarExpansionFactor field.
Definition: Messages.h:6060
Message identifiers and length of message root.
Definition: Messages.h:8520
bool poolFactor(Uint32 &value) const noexcept
Provides access to poolFactor field.
Definition: Messages.h:4153
StrRef derivativesInstrumentTradingCode() const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition: Messages.h:5255
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:3450
BfInstrumentReference(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:8624
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4990
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9072
SchemaTraits Schema
Used template schema.
Definition: Messages.h:9485
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:9515
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition: Messages.h:9745
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition: Messages.h:1747
bool tradingPeriod(TradingPeriod::Enum &value) const noexcept
Provides access to tradingPeriod field.
Definition: Messages.h:2622
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:380
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:2569
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition: Messages.h:6014
bool scheduledEventTime(Uint64 &value) const noexcept
Provides access to scheduledEventTime field.
Definition: Messages.h:2699
bool highLevel(Int64 &value) const noexcept
Provides access to highLevel field.
Definition: Messages.h:4927
bool collarUnhaltDelay(Uint32 &value) const noexcept
Provides access to collarUnhaltDelay field.
Definition: Messages.h:5547
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:139
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9426
bool expiryDate(StrRef &value) const noexcept
Provides access to expiryDate field.
Definition: Messages.h:7829
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9107
bool firstSettlementDate(Uint16 &value) const noexcept
Provides access to firstSettlementDate field.
Definition: Messages.h:3688
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition: Messages.h:5916
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition: Messages.h:974
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition: Messages.h:3130
IntegralConstant< UInt8, 255 > NullUInt8
Definition: Fields.h:4725
bool legSymbolIndex(Uint32 &value) const noexcept
Provides access to legSymbolIndex field.
Definition: Messages.h:7065
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:3401
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:10092
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9447
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:2955
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition: Messages.h:8095
PriceUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1450
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition: Messages.h:483
Bfnav(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition: Messages.h:9494
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:6935
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:720