OnixS C++ CME MDP Conflated TCP Handler  1.3.6
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 
29 
31 
33 
34 /// MDInstrumentDefinitionFixedIncome.
37 : SbeMessage
38 {
39  /// Used template schema.
41 
42  /// This type alias.
44 
45  /// Message template ID from SBE schema.
46  enum { TemplateId = 57 };
47 
48  /// Number of repeating EventType entries.
49  /// Entry of EventsEntry repeating group.
52  <
54  >
55  {
56  /// Base class type.
57  typedef
59  <
61  >
63 
64  /// This type alias.
66 
67  /// Initializes instance of given
68  /// version over given memory block.
70  void* data,
71  EncodedLength length,
72  SchemaVersion version)
73  : Base(data, length, version)
74  {
75  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
76  assert(length >= minimalBlockLength(version));
77  }
78 
79  /// Reset all variable-length fields if any.
80  ThisType& resetVariableFields()
82  {
83  return *this;
84  }
85 
86  /// Reset all variable-length and optional fields if any.
87  ThisType& reset()
89  {
90  resetVariableFields();
91  return *this;
92  }
93 
94  /// Code to represent the type of event.
98  {
100 
101  return enumeration<EventType>(offset);
102  }
103 
104  /// Code to represent the type of event.
105  ThisType& setEventType(EventType::Enum value)
107  {
109 
110  setEnumeration<EventType>(offset, value);
111  return *this;
112  }
113 
114  /// Date and Time of instrument Activation or Expiration event
115  /// sent as number of nanoseconds since Unix epoch.
119  {
121 
122  return ordinary<Timestamp>(offset);
123  }
124 
125  /// Date and Time of instrument Activation or Expiration event
126  /// sent as number of nanoseconds since Unix epoch.
127  ThisType& setEventTime(Timestamp value)
129  {
131 
132  setOrdinary(offset, value.sinceEpoch());
133  return *this;
134  }
135 
136  /// \return size of entry body in bytes
137  /// for given version of message template.
142  {
143  return
144  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
145  minimalBlockLength(version);
146  }
147 
148  /// \return minimal size of entry body in bytes
149  /// for given version of message template.
152  static
157  {
158  return
159  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
160  9;
161  }
162 
163  /// Entity class name.
167  static const Char* className()
168  {
169  return "InstrumentDefinitionFixedIncome57.EventsEntry";
170  }
171  };
172 
173  /// Repeating group containing EventsEntry entries.
174  typedef
177 
178  /// Number of repeating FeedType repeating group entries.
179  /// Entry of FeedTypesEntry repeating group.
182  <
184  >
185  {
186  /// Base class type.
187  typedef
189  <
191  >
193 
194  /// This type alias.
196 
197  /// Initializes instance of given
198  /// version over given memory block.
200  void* data,
201  EncodedLength length,
202  SchemaVersion version)
203  : Base(data, length, version)
204  {
205  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
206  assert(length >= minimalBlockLength(version));
207  }
208 
209  /// Reset all variable-length fields if any.
212  {
213  return *this;
214  }
215 
216  /// Reset all variable-length and optional fields if any.
217  ThisType& reset()
219  {
220  resetVariableFields();
221  return *this;
222  }
223 
224  /// Describes a class of service for a given data feed. GBX-
225  /// Real Book, GBI-Implied Book.
227  StrRef feedType() const
229  {
232 
233  return fixedStr<length>(offset);
234  }
235 
236  /// Describes a class of service for a given data feed. GBX-
237  /// Real Book, GBI-Implied Book.
238  ThisType& setFeedType(StrRef value)
240  {
243 
244  setFixedStr<length>(offset, value);
245  return *this;
246  }
247 
248  /// book depth.
252  {
254 
255  return ordinary<Int8>(offset);
256  }
257 
258  /// book depth.
259  ThisType& setMarketDepth(Int8 value)
261  {
263 
264  setOrdinary(offset, value);
265  return *this;
266  }
267 
268  /// \return size of entry body in bytes
269  /// for given version of message template.
274  {
275  return
276  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
277  minimalBlockLength(version);
278  }
279 
280  /// \return minimal size of entry body in bytes
281  /// for given version of message template.
284  static
289  {
290  return
291  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
292  4;
293  }
294 
295  /// Entity class name.
299  static const Char* className()
300  {
301  return "InstrumentDefinitionFixedIncome57.FeedTypesEntry";
302  }
303  };
304 
305  /// Repeating group containing FeedTypesEntry entries.
306  typedef
309 
310  /// Number of repeating InstrAttribType entries.
311  /// Entry of InstAttribEntry repeating group.
314  <
316  >
317  {
318  /// Base class type.
319  typedef
321  <
323  >
325 
326  /// This type alias.
328 
329  /// Initializes instance of given
330  /// version over given memory block.
332  void* data,
333  EncodedLength length,
334  SchemaVersion version)
335  : Base(data, length, version)
336  {
337  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
338  assert(length >= minimalBlockLength(version));
339  }
340 
341  /// Reset all variable-length fields if any.
344  {
345  return *this;
346  }
347 
348  /// Reset all variable-length and optional fields if any.
349  ThisType& reset()
351  {
352  resetVariableFields();
353  return *this;
354  }
355 
356  /// Instrument eligibility attributes.
361  {
362  return InstAttribType();
363  }
364 
365  /// Bitmap field of 32 Boolean type instrument eligibility
366  /// flags.
370  {
372 
373  return ordinary<InstAttribValue>(offset);
374  }
375 
376  /// Bitmap field of 32 Boolean type instrument eligibility
377  /// flags.
380  {
382 
383  setOrdinary(offset, value);
384  return *this;
385  }
386 
387  /// \return size of entry body in bytes
388  /// for given version of message template.
393  {
394  return
395  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
396  minimalBlockLength(version);
397  }
398 
399  /// \return minimal size of entry body in bytes
400  /// for given version of message template.
403  static
408  {
409  return
410  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
411  4;
412  }
413 
414  /// Entity class name.
418  static const Char* className()
419  {
420  return "InstrumentDefinitionFixedIncome57.InstAttribEntry";
421  }
422  };
423 
424  /// Repeating group containing InstAttribEntry entries.
425  typedef
428 
429  /// Number of entries.
430  /// Entry of LotTypeRulesEntry repeating group.
433  <
435  >
436  {
437  /// Base class type.
438  typedef
440  <
442  >
444 
445  /// This type alias.
447 
448  /// Initializes instance of given
449  /// version over given memory block.
451  void* data,
452  EncodedLength length,
453  SchemaVersion version)
454  : Base(data, length, version)
455  {
456  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
457  assert(length >= minimalBlockLength(version));
458  }
459 
460  /// Reset all variable-length fields if any.
463  {
464  return *this;
465  }
466 
467  /// Reset all variable-length and optional fields if any.
468  ThisType& reset()
470  {
471  minLotSizeNull();
472 
473  resetVariableFields();
474  return *this;
475  }
476 
477  /// This tag is required to interpret the value in tag
478  /// 1231-MinLotSize.
480  Int8 lotType() const
482  {
484 
485  return ordinary<Int8>(offset);
486  }
487 
488  /// This tag is required to interpret the value in tag
489  /// 1231-MinLotSize.
490  ThisType& setLotType(Int8 value)
492  {
494 
495  setOrdinary(offset, value);
496  return *this;
497  }
498 
499  /// Minimum quantity accepted for order entry. If tag
500  /// 1093-LotType=4, this value is the minimum quantity for
501  /// order entry expressed in the applicable units, specified
502  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
503  /// 1093-LotType= 5, this value represents order qty increment.
505  bool minLotSize(DecimalQty& value) const
507  {
509 
510  return decimal(value, offset, NullDecimalQty());
511  }
512 
513  /// Minimum quantity accepted for order entry. If tag
514  /// 1093-LotType=4, this value is the minimum quantity for
515  /// order entry expressed in the applicable units, specified
516  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
517  /// 1093-LotType= 5, this value represents order qty increment.
518  ThisType& setMinLotSize(DecimalQty value)
520  {
522 
523  setOrdinary(offset, value);
524  return *this;
525  }
526 
527  ThisType& minLotSizeNull()
529  {
531 
532  setOrdinary(offset, NullDecimalQty());
533  return *this;
534  }
535 
536  /// \return size of entry body in bytes
537  /// for given version of message template.
542  {
543  return
544  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
545  minimalBlockLength(version);
546  }
547 
548  /// \return minimal size of entry body in bytes
549  /// for given version of message template.
552  static
557  {
558  return
559  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
560  5;
561  }
562 
563  /// Entity class name.
567  static const Char* className()
568  {
569  return "InstrumentDefinitionFixedIncome57.LotTypeRulesEntry";
570  }
571  };
572 
573  /// Repeating group containing LotTypeRulesEntry entries.
574  typedef
577 
578  /// Initializes a blank instance.
580 
581  /// Initializes an instance over the given memory block.
583  void* data,
584  EncodedLength length,
585  SchemaVersion version = Schema::Version)
586  : SbeMessage(data, length, version)
587  {
588  checkVersion<Schema>(version);
589  checkLength(length, version);
590  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
591  reset();
592  }
593 
594  /// Initializes an instance over the given memory block
595  /// With no variable-length fields initialization
596  /// It is assumed that the user does such an initialization manually.
598  void* data,
599  EncodedLength length,
600  NoFieldsInit,
601  SchemaVersion version = Schema::Version)
602  : SbeMessage(data, length, version)
603  {
604  checkVersion<Schema>(version);
605  checkLength(length, version);
606  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
607  resetVariableFields();
608  }
609 
610  /// Creates an instance over the given memory block.
612  void* data,
613  EncodedLength length,
614  NoInit)
615  : SbeMessage(data, length)
616  {
617  checkCompatibility();
618  }
619 
620  /// Creates an instance over the given SBE message.
621  explicit
623  const SbeMessage& message)
624  : SbeMessage(message)
625  {
626  assert(message.valid());
627 
628  checkCompatibility();
629  }
630 
631  /// Bitmap field of eight Boolean type indicators reflecting
632  /// the end of updates for a given Globex event.
636  {
638 
639  return ordinary<MatchEventIndicator>(offset);
640  }
641 
642  /// Bitmap field of eight Boolean type indicators reflecting
643  /// the end of updates for a given Globex event.
644  ThisType&
646  MatchEventIndicator value)
648  {
650 
651  setOrdinary(offset, value);
652  return *this;
653  }
654 
655  /// Total number of instruments in the Replay loop. Used on
656  /// Replay Feed only.
658  bool totNumReports(UInt32& value) const
660  {
662 
663  return ordinary(value, offset, NullUInt32());
664  }
665 
666  /// Total number of instruments in the Replay loop. Used on
667  /// Replay Feed only.
668  ThisType& setTotNumReports(UInt32 value)
670  {
672 
673  setOrdinary(offset, value);
674  return *this;
675  }
676 
677  ThisType& totNumReportsNull()
679  {
681 
682  setOrdinary(offset, NullUInt32());
683  return *this;
684  }
685 
686  /// Last Security update action on Incremental feed, 'D' or
687  /// 'M' is used when a mid-week deletion or modification (i.e.
688  /// extension) occurs.
693  {
695 
696  return enumeration<SecurityUpdateAction>(offset);
697  }
698 
699  /// Last Security update action on Incremental feed, 'D' or
700  /// 'M' is used when a mid-week deletion or modification (i.e.
701  /// extension) occurs.
702  ThisType&
706  {
708 
709  setEnumeration<SecurityUpdateAction>(offset, value);
710  return *this;
711  }
712 
713  /// Timestamp of when the instrument was last added, modified
714  /// or deleted.
718  {
720 
721  return ordinary<Timestamp>(offset);
722  }
723 
724  /// Timestamp of when the instrument was last added, modified
725  /// or deleted.
726  ThisType& setLastUpdateTime(Timestamp value)
728  {
730 
731  setOrdinary(offset, value.sinceEpoch());
732  return *this;
733  }
734 
735  /// Identifies the current market state of the instrument.
737  bool
739  SecurityTradingStatus::Enum& value) const
741  {
743 
744  return enumeration<SecurityTradingStatus>(value, offset, NullUInt8());
745  }
746 
747  /// Identifies the current market state of the instrument.
748  ThisType&
752  {
754 
755  setEnumeration<SecurityTradingStatus>(offset, value);
756  return *this;
757  }
758 
761  {
763 
764  setOrdinary(offset, NullUInt8());
765  return *this;
766  }
767 
768  /// MD channel ID as defined in the XML Configuration file.
770  Int16 applId() const
772  {
774 
775  return ordinary<Int16>(offset);
776  }
777 
778  /// MD channel ID as defined in the XML Configuration file.
779  ThisType& setApplId(Int16 value)
781  {
783 
784  setOrdinary(offset, value);
785  return *this;
786  }
787 
788  /// Identifies the market segment for all CME Globex
789  /// instruments.
793  {
795 
796  return ordinary<UInt8>(offset);
797  }
798 
799  /// Identifies the market segment for all CME Globex
800  /// instruments.
801  ThisType& setMarketSegmentId(UInt8 value)
803  {
805 
806  setOrdinary(offset, value);
807  return *this;
808  }
809 
810  /// Indicates the product complex.
814  {
816 
817  return ordinary<UInt8>(offset);
818  }
819 
820  /// Indicates the product complex.
821  ThisType& setUnderlyingProduct(UInt8 value)
823  {
825 
826  setOrdinary(offset, value);
827  return *this;
828  }
829 
830  /// Exchange used to identify a security.
834  {
837 
838  return fixedStr<length>(offset);
839  }
840 
841  /// Exchange used to identify a security.
842  ThisType& setSecurityExchange(StrRef value)
844  {
847 
848  setFixedStr<length>(offset, value);
849  return *this;
850  }
851 
852  /// Security Group Code.
856  {
859 
860  return fixedStr<length>(offset);
861  }
862 
863  /// Security Group Code.
864  ThisType& setSecurityGroup(StrRef value)
866  {
869 
870  setFixedStr<length>(offset, value);
871  return *this;
872  }
873 
874  /// The underlying asset code also known as Product Code.
876  StrRef asset() const
878  {
881 
882  return fixedStr<length>(offset);
883  }
884 
885  /// The underlying asset code also known as Product Code.
886  ThisType& setAsset(StrRef value)
888  {
891 
892  setFixedStr<length>(offset, value);
893  return *this;
894  }
895 
896  /// Instrument Name or Symbol.
898  StrRef symbol() const
900  {
903 
904  return fixedStr<length>(offset);
905  }
906 
907  /// Instrument Name or Symbol.
908  ThisType& setSymbol(StrRef value)
910  {
913 
914  setFixedStr<length>(offset, value);
915  return *this;
916  }
917 
918  /// Unique instrument ID.
922  {
924 
925  return ordinary<Int32>(offset);
926  }
927 
928  /// Unique instrument ID.
929  ThisType& setSecurityId(Int32 value)
931  {
933 
934  setOrdinary(offset, value);
935  return *this;
936  }
937 
938  /// Identifies class or source of Tag 48-SecurityID value.
943  {
944  return SecurityIDSource();
945  }
946 
947  /// Security Type.
951  {
954 
955  return fixedStr<length>(offset);
956  }
957 
958  /// Security Type.
959  ThisType& setSecurityType(StrRef value)
961  {
964 
965  setFixedStr<length>(offset, value);
966  return *this;
967  }
968 
969  /// ISO standard instrument categorization code.
971  StrRef cfiCode() const
973  {
976 
977  return fixedStr<length>(offset);
978  }
979 
980  /// ISO standard instrument categorization code.
981  ThisType& setCfiCode(StrRef value)
983  {
986 
987  setFixedStr<length>(offset, value);
988  return *this;
989  }
990 
991  /// Identifies the currency used for price.
993  StrRef currency() const
995  {
998 
999  return fixedStr<length>(offset);
1000  }
1001 
1002  /// Identifies the currency used for price.
1003  ThisType& setCurrency(StrRef value)
1005  {
1008 
1009  setFixedStr<length>(offset, value);
1010  return *this;
1011  }
1012 
1013  /// Identifies currency used for settlement, if different from
1014  /// trade price currency.
1018  {
1021 
1022  return fixedStr<length>(offset);
1023  }
1024 
1025  /// Identifies currency used for settlement, if different from
1026  /// trade price currency.
1027  ThisType& setSettlCurrency(StrRef value)
1029  {
1032 
1033  setFixedStr<length>(offset, value);
1034  return *this;
1035  }
1036 
1037  /// Matching Algorithm.
1041  {
1043 
1044  return ordinary<CHAR>(offset);
1045  }
1046 
1047  /// Matching Algorithm.
1048  ThisType& setMatchAlgorithm(CHAR value)
1050  {
1052 
1053  setOrdinary(offset, value);
1054  return *this;
1055  }
1056 
1057  /// The minimum trading volume for a security.
1061  {
1063 
1064  return ordinary<UInt32>(offset);
1065  }
1066 
1067  /// The minimum trading volume for a security.
1068  ThisType& setMinTradeVol(UInt32 value)
1070  {
1072 
1073  setOrdinary(offset, value);
1074  return *this;
1075  }
1076 
1077  /// The maximum trading volume for a security.
1081  {
1083 
1084  return ordinary<UInt32>(offset);
1085  }
1086 
1087  /// The maximum trading volume for a security.
1088  ThisType& setMaxTradeVol(UInt32 value)
1090  {
1092 
1093  setOrdinary(offset, value);
1094  return *this;
1095  }
1096 
1097  /// Minimum constant tick for the instrument, sent only if
1098  /// instrument is non-VTT (Variable Tick table) eligible.
1100  bool minPriceIncrement(PRICE9& value) const
1102  {
1104 
1105  return decimal(value, offset, NullPRICE9());
1106  }
1107 
1108  /// Minimum constant tick for the instrument, sent only if
1109  /// instrument is non-VTT (Variable Tick table) eligible.
1110  ThisType& setMinPriceIncrement(PRICE9 value)
1112  {
1114 
1115  setOrdinary(offset, value);
1116  return *this;
1117  }
1118 
1121  {
1123 
1124  setOrdinary(offset, NullPRICE9());
1125  return *this;
1126  }
1127 
1128  /// Contains the multiplier to convert the CME Globex display
1129  /// price to the conventional price.
1133  {
1135 
1136  return decimal<Decimal9>(offset);
1137  }
1138 
1139  /// Contains the multiplier to convert the CME Globex display
1140  /// price to the conventional price.
1141  ThisType& setDisplayFactor(Decimal9 value)
1143  {
1145 
1146  setOrdinary(offset, value);
1147  return *this;
1148  }
1149 
1150  /// Price Denominator of Main Fraction.
1152  bool mainFraction(UInt8& value) const
1154  {
1156 
1157  return ordinary(value, offset, NullUInt8());
1158  }
1159 
1160  /// Price Denominator of Main Fraction.
1161  ThisType& setMainFraction(UInt8 value)
1163  {
1165 
1166  setOrdinary(offset, value);
1167  return *this;
1168  }
1169 
1170  ThisType& mainFractionNull()
1172  {
1174 
1175  setOrdinary(offset, NullUInt8());
1176  return *this;
1177  }
1178 
1179  /// Price Denominator of Sub Fraction.
1181  bool subFraction(UInt8& value) const
1183  {
1185 
1186  return ordinary(value, offset, NullUInt8());
1187  }
1188 
1189  /// Price Denominator of Sub Fraction.
1190  ThisType& setSubFraction(UInt8 value)
1192  {
1194 
1195  setOrdinary(offset, value);
1196  return *this;
1197  }
1198 
1199  ThisType& subFractionNull()
1201  {
1203 
1204  setOrdinary(offset, NullUInt8());
1205  return *this;
1206  }
1207 
1208  /// Number of Decimals in Displayed Price.
1210  bool priceDisplayFormat(UInt8& value) const
1212  {
1214 
1215  return ordinary(value, offset, NullUInt8());
1216  }
1217 
1218  /// Number of Decimals in Displayed Price.
1219  ThisType& setPriceDisplayFormat(UInt8 value)
1221  {
1223 
1224  setOrdinary(offset, value);
1225  return *this;
1226  }
1227 
1230  {
1232 
1233  setOrdinary(offset, NullUInt8());
1234  return *this;
1235  }
1236 
1237  /// Unit of measure for the products' original contract size.
1238  /// This will be populated for all products listed on CME
1239  /// Globex.
1243  {
1246 
1247  return fixedStr<length>(offset);
1248  }
1249 
1250  /// Unit of measure for the products' original contract size.
1251  /// This will be populated for all products listed on CME
1252  /// Globex.
1253  ThisType& setUnitOfMeasure(StrRef value)
1255  {
1258 
1259  setFixedStr<length>(offset, value);
1260  return *this;
1261  }
1262 
1263  /// This field contains the contract size for each instrument.
1264  /// Use in combination with tag 996-UnitofMeasure.
1266  bool unitOfMeasureQty(Decimal9& value) const
1268  {
1270 
1271  return decimal(value, offset, NullDecimal9());
1272  }
1273 
1274  /// This field contains the contract size for each instrument.
1275  /// Use in combination with tag 996-UnitofMeasure.
1278  {
1280 
1281  setOrdinary(offset, value);
1282  return *this;
1283  }
1284 
1287  {
1289 
1290  setOrdinary(offset, NullDecimal9());
1291  return *this;
1292  }
1293 
1294  /// Trading Reference Price.
1296  bool tradingReferencePrice(PRICE9& value) const
1298  {
1300 
1301  return decimal(value, offset, NullPRICE9());
1302  }
1303 
1304  /// Trading Reference Price.
1307  {
1309 
1310  setOrdinary(offset, value);
1311  return *this;
1312  }
1313 
1316  {
1318 
1319  setOrdinary(offset, NullPRICE9());
1320  return *this;
1321  }
1322 
1323  /// Indicates session date corresponding to the reference
1324  /// price in tag 1150-TradingReferencePrice.
1326  bool tradingReferenceDate(Timestamp& value) const
1328  {
1329  typedef LocalMktDate FieldValue;
1330 
1332 
1333  FieldValue fieldValue;
1334 
1335  if (ordinary(fieldValue, offset, NullLocalMktDate()))
1336  {
1337  value = localMktDateToTimestamp(fieldValue);
1338  return true;
1339  }
1340  return false;
1341  }
1342 
1343  /// Indicates session date corresponding to the reference
1344  /// price in tag 1150-TradingReferencePrice.
1347  {
1349 
1350  setOrdinary(offset, timestampToLocalMktDate(value));
1351  return *this;
1352  }
1353 
1356  {
1358 
1359  setOrdinary(offset, NullLocalMktDate());
1360  return *this;
1361  }
1362 
1363  /// Allowable high limit price for the trading day.
1365  bool highLimitPrice(PRICE9& value) const
1367  {
1369 
1370  return decimal(value, offset, NullPRICE9());
1371  }
1372 
1373  /// Allowable high limit price for the trading day.
1374  ThisType& setHighLimitPrice(PRICE9 value)
1376  {
1378 
1379  setOrdinary(offset, value);
1380  return *this;
1381  }
1382 
1385  {
1387 
1388  setOrdinary(offset, NullPRICE9());
1389  return *this;
1390  }
1391 
1392  /// Allowable low limit price for the trading day.
1394  bool lowLimitPrice(PRICE9& value) const
1396  {
1398 
1399  return decimal(value, offset, NullPRICE9());
1400  }
1401 
1402  /// Allowable low limit price for the trading day.
1403  ThisType& setLowLimitPrice(PRICE9 value)
1405  {
1407 
1408  setOrdinary(offset, value);
1409  return *this;
1410  }
1411 
1412  ThisType& lowLimitPriceNull()
1414  {
1416 
1417  setOrdinary(offset, NullPRICE9());
1418  return *this;
1419  }
1420 
1421  /// Differential value for price banding.
1423  bool maxPriceVariation(PRICE9& value) const
1425  {
1427 
1428  return decimal(value, offset, NullPRICE9());
1429  }
1430 
1431  /// Differential value for price banding.
1432  ThisType& setMaxPriceVariation(PRICE9 value)
1434  {
1436 
1437  setOrdinary(offset, value);
1438  return *this;
1439  }
1440 
1443  {
1445 
1446  setOrdinary(offset, NullPRICE9());
1447  return *this;
1448  }
1449 
1450  /// Monetary value equivalent to the minimum price
1451  /// fluctuation.
1453  bool minPriceIncrementAmount(PRICE9& value) const
1455  {
1457 
1458  return decimal(value, offset, NullPRICE9());
1459  }
1460 
1461  /// Monetary value equivalent to the minimum price
1462  /// fluctuation.
1465  {
1467 
1468  setOrdinary(offset, value);
1469  return *this;
1470  }
1471 
1474  {
1476 
1477  setOrdinary(offset, NullPRICE9());
1478  return *this;
1479  }
1480 
1481  /// Issue Date.
1483  bool issueDate(Timestamp& value) const
1485  {
1486  typedef LocalMktDate FieldValue;
1487 
1489 
1490  FieldValue fieldValue;
1491 
1492  if (ordinary(fieldValue, offset, NullLocalMktDate()))
1493  {
1494  value = localMktDateToTimestamp(fieldValue);
1495  return true;
1496  }
1497  return false;
1498  }
1499 
1500  /// Issue Date.
1501  ThisType& setIssueDate(Timestamp value)
1503  {
1505 
1506  setOrdinary(offset, timestampToLocalMktDate(value));
1507  return *this;
1508  }
1509 
1510  ThisType& issueDateNull()
1512  {
1514 
1515  setOrdinary(offset, NullLocalMktDate());
1516  return *this;
1517  }
1518 
1519  /// Dated Date.
1521  bool datedDate(Timestamp& value) const
1523  {
1524  typedef LocalMktDate FieldValue;
1525 
1527 
1528  FieldValue fieldValue;
1529 
1530  if (ordinary(fieldValue, offset, NullLocalMktDate()))
1531  {
1532  value = localMktDateToTimestamp(fieldValue);
1533  return true;
1534  }
1535  return false;
1536  }
1537 
1538  /// Dated Date.
1539  ThisType& setDatedDate(Timestamp value)
1541  {
1543 
1544  setOrdinary(offset, timestampToLocalMktDate(value));
1545  return *this;
1546  }
1547 
1548  ThisType& datedDateNull()
1550  {
1552 
1553  setOrdinary(offset, NullLocalMktDate());
1554  return *this;
1555  }
1556 
1557  /// Maturity Date.
1559  bool maturityDate(Timestamp& value) const
1561  {
1562  typedef LocalMktDate FieldValue;
1563 
1565 
1566  FieldValue fieldValue;
1567 
1568  if (ordinary(fieldValue, offset, NullLocalMktDate()))
1569  {
1570  value = localMktDateToTimestamp(fieldValue);
1571  return true;
1572  }
1573  return false;
1574  }
1575 
1576  /// Maturity Date.
1577  ThisType& setMaturityDate(Timestamp value)
1579  {
1581 
1582  setOrdinary(offset, timestampToLocalMktDate(value));
1583  return *this;
1584  }
1585 
1586  ThisType& maturityDateNull()
1588  {
1590 
1591  setOrdinary(offset, NullLocalMktDate());
1592  return *this;
1593  }
1594 
1595  /// The rate of interest that, when multiplied by the
1596  /// principal, par value, or face value of a bond, provides
1597  /// the currency amount of the periodic interest payment.
1599  bool couponRate(Decimal9& value) const
1601  {
1603 
1604  return decimal(value, offset, NullDecimal9());
1605  }
1606 
1607  /// The rate of interest that, when multiplied by the
1608  /// principal, par value, or face value of a bond, provides
1609  /// the currency amount of the periodic interest payment.
1610  ThisType& setCouponRate(Decimal9 value)
1612  {
1614 
1615  setOrdinary(offset, value);
1616  return *this;
1617  }
1618 
1619  ThisType& couponRateNull()
1621  {
1623 
1624  setOrdinary(offset, NullDecimal9());
1625  return *this;
1626  }
1627 
1628  /// Par value.
1630  bool parValue(PRICE9& value) const
1632  {
1634 
1635  return decimal(value, offset, NullPRICE9());
1636  }
1637 
1638  /// Par value.
1639  ThisType& setParValue(PRICE9 value)
1641  {
1643 
1644  setOrdinary(offset, value);
1645  return *this;
1646  }
1647 
1648  ThisType& parValueNull()
1650  {
1652 
1653  setOrdinary(offset, NullPRICE9());
1654  return *this;
1655  }
1656 
1657  /// Time unit associated with the frequency of the bond's
1658  /// coupon payment.
1662  {
1665 
1666  return fixedStr<length>(offset);
1667  }
1668 
1669  /// Time unit associated with the frequency of the bond's
1670  /// coupon payment.
1673  {
1676 
1677  setFixedStr<length>(offset, value);
1678  return *this;
1679  }
1680 
1681  /// Time unit multiplier for the frequency of the bond's
1682  /// coupon payment.
1684  bool couponFrequencyPeriod(UInt16& value) const
1686  {
1688 
1689  return ordinary(value, offset, NullUInt16());
1690  }
1691 
1692  /// Time unit multiplier for the frequency of the bond's
1693  /// coupon payment.
1696  {
1698 
1699  setOrdinary(offset, value);
1700  return *this;
1701  }
1702 
1705  {
1707 
1708  setOrdinary(offset, NullUInt16());
1709  return *this;
1710  }
1711 
1712  /// The day count convention used in interest calculations for
1713  /// a bond or an interest bearing security.
1717  {
1720 
1721  return fixedStr<length>(offset);
1722  }
1723 
1724  /// The day count convention used in interest calculations for
1725  /// a bond or an interest bearing security.
1726  ThisType& setCouponDayCount(StrRef value)
1728  {
1731 
1732  setFixedStr<length>(offset, value);
1733  return *this;
1734  }
1735 
1736  /// Country of Origin, ISO alpha-2 country code.
1740  {
1743 
1744  return fixedStr<length>(offset);
1745  }
1746 
1747  /// Country of Origin, ISO alpha-2 country code.
1748  ThisType& setCountryOfIssue(StrRef value)
1750  {
1753 
1754  setFixedStr<length>(offset, value);
1755  return *this;
1756  }
1757 
1758  /// Name of security issuer or the Legal Entity Identifier
1759  /// (LEI - the International ISO standard 17442).
1761  StrRef issuer() const
1763  {
1766 
1767  return fixedStr<length>(offset);
1768  }
1769 
1770  /// Name of security issuer or the Legal Entity Identifier
1771  /// (LEI - the International ISO standard 17442).
1772  ThisType& setIssuer(StrRef value)
1774  {
1777 
1778  setFixedStr<length>(offset, value);
1779  return *this;
1780  }
1781 
1782  /// Long name of the instrument.
1786  {
1789 
1790  return fixedStr<length>(offset);
1791  }
1792 
1793  /// Long name of the instrument.
1796  {
1799 
1800  setFixedStr<length>(offset, value);
1801  return *this;
1802  }
1803 
1804  /// Expanded instrument description. Will contain either ISIN
1805  /// or CUSIP.
1809  {
1812 
1813  return fixedStr<length>(offset);
1814  }
1815 
1816  /// Expanded instrument description. Will contain either ISIN
1817  /// or CUSIP.
1818  ThisType& setSecurityAltId(StrRef value)
1820  {
1823 
1824  setFixedStr<length>(offset, value);
1825  return *this;
1826  }
1827 
1828  /// Identifies class or source of the SecurityAltID (455)
1829  /// value.
1831  bool
1833  SecurityAltIDSource::Enum& value) const
1835  {
1837 
1838  return enumeration<SecurityAltIDSource>(value, offset, NullUInt8());
1839  }
1840 
1841  /// Identifies class or source of the SecurityAltID (455)
1842  /// value.
1843  ThisType&
1847  {
1849 
1850  setEnumeration<SecurityAltIDSource>(offset, value);
1851  return *this;
1852  }
1853 
1856  {
1858 
1859  setOrdinary(offset, NullUInt8());
1860  return *this;
1861  }
1862 
1863  /// Price quotation method.
1867  {
1870 
1871  return fixedStr<length>(offset);
1872  }
1873 
1874  /// Price quotation method.
1875  ThisType& setPriceQuoteMethod(StrRef value)
1877  {
1880 
1881  setFixedStr<length>(offset, value);
1882  return *this;
1883  }
1884 
1885  /// Clearing organization.
1889  {
1892 
1893  return fixedStr<length>(offset);
1894  }
1895 
1896  /// Clearing organization.
1899  {
1902 
1903  setFixedStr<length>(offset, value);
1904  return *this;
1905  }
1906 
1907  /// User-defined Instrument flag.
1911  {
1913 
1914  return ordinary<UserDefinedInstrument>(offset);
1915  }
1916 
1917  /// User-defined Instrument flag.
1918  ThisType&
1920  UserDefinedInstrument value)
1922  {
1924 
1925  setOrdinary(offset, value);
1926  return *this;
1927  }
1928 
1929  /// Risk Set identifies the list of instruments sharing credit
1930  /// limits set up.
1932  StrRef riskSet() const
1934  {
1937 
1938  return fixedStr<length>(offset);
1939  }
1940 
1941  /// Risk Set identifies the list of instruments sharing credit
1942  /// limits set up.
1943  ThisType& setRiskSet(StrRef value)
1945  {
1948 
1949  setFixedStr<length>(offset, value);
1950  return *this;
1951  }
1952 
1953  /// Market Set defines the bilateral relationship and Self
1954  /// Match Prevention configuration for eligible markets.
1958  {
1961 
1962  return fixedStr<length>(offset);
1963  }
1964 
1965  /// Market Set defines the bilateral relationship and Self
1966  /// Match Prevention configuration for eligible markets.
1967  ThisType& setMarketSet(StrRef value)
1969  {
1972 
1973  setFixedStr<length>(offset, value);
1974  return *this;
1975  }
1976 
1977  /// External unique instrument ID.
1979  bool instrumentGUId(UInt64& value) const
1981  {
1983 
1984  return ordinary(value, offset, NullUInt64());
1985  }
1986 
1987  /// External unique instrument ID.
1988  ThisType& setInstrumentGUId(UInt64 value)
1990  {
1992 
1993  setOrdinary(offset, value);
1994  return *this;
1995  }
1996 
1999  {
2001 
2002  setOrdinary(offset, NullUInt64());
2003  return *this;
2004  }
2005 
2006  /// \return instance of Events repeating group.
2008  Events events() const
2010  {
2011  return getGroup<Events>(EventsAccess(), *this);
2012  }
2013 
2014  /// \return instance of Events repeating group.
2018  {
2019  return getGroup<Events>(EventsAccess(), *this);
2020  }
2021 
2022  /// Setup repeating group with the given number of entries.
2023  /// Sets all optional fields of the group entries to null.
2024  /// \return NoEvents(864) repeating group.
2026  {
2027  return constructGroup<Events>(
2028  EventsAccess(),
2029  length,
2030  *this);
2031  }
2032 
2033  /// Setup repeating group with the given number of entries.
2034  /// \return NoEvents(864) repeating group.
2035  Events
2037  Events::Size length,
2038  NoFieldsInit)
2039  {
2040  return setupGroup<Events>(
2041  EventsAccess(),
2042  length,
2043  *this);
2044  }
2045 
2046  /// \return instance of FeedTypes repeating group.
2050  {
2051  return getGroup<FeedTypes>(FeedTypesAccess(), *this);
2052  }
2053 
2054  /// \return instance of FeedTypes repeating group.
2058  {
2059  return getGroup<FeedTypes>(FeedTypesAccess(), *this);
2060  }
2061 
2062  /// Setup repeating group with the given number of entries.
2063  /// Sets all optional fields of the group entries to null.
2064  /// \return NoMDFeedTypes(1141) repeating group.
2066  {
2067  return constructGroup<FeedTypes>(
2068  FeedTypesAccess(),
2069  length,
2070  *this);
2071  }
2072 
2073  /// Setup repeating group with the given number of entries.
2074  /// \return NoMDFeedTypes(1141) repeating group.
2075  FeedTypes
2077  FeedTypes::Size length,
2078  NoFieldsInit)
2079  {
2080  return setupGroup<FeedTypes>(
2081  FeedTypesAccess(),
2082  length,
2083  *this);
2084  }
2085 
2086  /// \return instance of InstAttrib repeating group.
2090  {
2091  return getGroup<InstAttrib>(
2092  InstAttribAccess(),
2093  *this);
2094  }
2095 
2096  /// \return instance of InstAttrib repeating group.
2100  {
2101  return getGroup<InstAttrib>(
2102  InstAttribAccess(),
2103  *this);
2104  }
2105 
2106  /// Setup repeating group with the given number of entries.
2107  /// Sets all optional fields of the group entries to null.
2108  /// \return NoInstAttrib(870) repeating group.
2110  {
2111  return constructGroup<InstAttrib>(
2112  InstAttribAccess(),
2113  length,
2114  *this);
2115  }
2116 
2117  /// Setup repeating group with the given number of entries.
2118  /// \return NoInstAttrib(870) repeating group.
2119  InstAttrib
2121  InstAttrib::Size length,
2122  NoFieldsInit)
2123  {
2124  return setupGroup<InstAttrib>(
2125  InstAttribAccess(),
2126  length,
2127  *this);
2128  }
2129 
2130  /// \return instance of LotTypeRules repeating group.
2134  {
2135  return getGroup<LotTypeRules>(
2136  LotTypeRulesAccess(),
2137  *this);
2138  }
2139 
2140  /// \return instance of LotTypeRules repeating group.
2144  {
2145  return getGroup<LotTypeRules>(
2146  LotTypeRulesAccess(),
2147  *this);
2148  }
2149 
2150  /// Setup repeating group with the given number of entries.
2151  /// Sets all optional fields of the group entries to null.
2152  /// \return NoLotTypeRules(1234) repeating group.
2153  LotTypeRules
2155  LotTypeRules::Size length)
2156  {
2157  return constructGroup<LotTypeRules>(
2158  LotTypeRulesAccess(),
2159  length,
2160  *this);
2161  }
2162 
2163  /// Setup repeating group with the given number of entries.
2164  /// \return NoLotTypeRules(1234) repeating group.
2165  LotTypeRules
2167  LotTypeRules::Size length,
2168  NoFieldsInit)
2169  {
2170  return setupGroup<LotTypeRules>(
2171  LotTypeRulesAccess(),
2172  length,
2173  *this);
2174  }
2175 
2176  /// Minimal size of message body in bytes.
2179  static
2180  BlockLength
2184  {
2185  return
2186  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2187  338;
2188  }
2189 
2190  /// Size of message body in bytes.
2195  {
2196  return
2197  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2198  minimalBlockLength(version);
2199  }
2200 
2201  /// Minimal variable fields size (when variable-length fields are empty).
2205  static
2206  MessageSize
2209  {
2210  return
2211  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2212  static_cast<MessageSize>(Events::EmptySize) + static_cast<MessageSize>(FeedTypes::EmptySize) + static_cast<MessageSize>(InstAttrib::EmptySize) + static_cast<MessageSize>(LotTypeRules::EmptySize);
2213  }
2214 
2215  /// Reset all variable-length fields if any.
2218  {
2219  eventsNull();
2220  feedTypesNull();
2221  instAttribNull();
2222  lotTypeRulesNull();
2223  return *this;
2224  }
2225 
2226  /// Reset all variable-length and optional fields if any.
2227  ThisType& reset()
2229  {
2230  totNumReportsNull();
2231  securityTradingStatusNull();
2232  minPriceIncrementNull();
2233  mainFractionNull();
2234  subFractionNull();
2235  priceDisplayFormatNull();
2236  unitOfMeasureQtyNull();
2237  tradingReferencePriceNull();
2238  tradingReferenceDateNull();
2239  highLimitPriceNull();
2240  lowLimitPriceNull();
2241  maxPriceVariationNull();
2242  minPriceIncrementAmountNull();
2243  issueDateNull();
2244  datedDateNull();
2245  maturityDateNull();
2246  couponRateNull();
2247  parValueNull();
2248  couponFrequencyPeriodNull();
2249  securityAltIdSourceNull();
2250  instrumentGUIdNull();
2251 
2252  resetVariableFields();
2253  return *this;
2254  }
2255 
2256  /// \return class name.
2260  static const Char* className()
2261  {
2262  return "InstrumentDefinitionFixedIncome57";
2263  }
2264 
2265  /// FIX message type.
2269  static StrRef fixType()
2271  {
2272  return constructStrRef("d");
2273  }
2274 
2275  /// \return the end of the message.
2277  const void* tail() const
2279  {
2280  return
2281  lotTypeRules().tail();
2282  }
2283 
2284  /// \return the size occupied by the message.
2288  {
2289  return
2290  SbeMessage::calculateBinarySize(tail());
2291  }
2292 
2293 private:
2294  void checkLength(
2295  EncodedLength length, SchemaVersion version) const
2296  {
2297  const EncodedLength minimalRequiredLength =
2298  minimalBlockLength(version) +
2299  MessageHeader::Size +
2300  getMinimalVariableFieldsSize(version);
2301 
2302  checkBinaryLength(
2303  *this, length, minimalRequiredLength);
2304  }
2305 
2306  /// Checks variable fields consistency.
2307  void checkVarLenFields() const
2308  {
2309  groups().
2310  checkTail<Events>().
2311  checkTail<FeedTypes>().
2312  checkTail<InstAttrib>().
2313  checkTail<LotTypeRules>();
2314  }
2315 
2316  void checkCompatibility() const
2317  {
2318  assert(TemplateId == templateId());
2319 
2320  checkSchema<Schema>(schemaId(), version());
2321  checkLength(bufferSize(), version());
2322  checkVarLenFields();
2323  }
2324 
2325  /// Access helper.
2326  struct EventsAccess
2327  {
2328  Events
2329  operator()(
2330  const InstrumentDefinitionFixedIncome57& obj) const
2332  {
2333  return obj.
2334  groups().
2335  head<Events>();
2336  }
2337  };
2338 
2339  /// Reset an instance of the repeating group.
2340  /// All the following data will be invalidated.
2341  void eventsNull()
2343  {
2344  resetGroup<Events>(EventsAccess(), *this);
2345  }
2346 
2347  /// Access helper.
2348  struct FeedTypesAccess
2349  {
2350  FeedTypes
2351  operator()(
2352  const InstrumentDefinitionFixedIncome57& obj) const
2354  {
2355  return obj.
2356  groups().
2357  tail<Events>().
2358  head<FeedTypes>();
2359  }
2360  };
2361 
2362  /// Reset an instance of the repeating group.
2363  /// All the following data will be invalidated.
2364  void feedTypesNull()
2366  {
2367  resetGroup<FeedTypes>(FeedTypesAccess(), *this);
2368  }
2369 
2370  /// Access helper.
2371  struct InstAttribAccess
2372  {
2373  InstAttrib
2374  operator()(
2375  const InstrumentDefinitionFixedIncome57& obj) const
2377  {
2378  return obj.
2379  groups().
2380  tail<Events>().
2381  tail<FeedTypes>().
2382  head<InstAttrib>();
2383  }
2384  };
2385 
2386  /// Reset an instance of the repeating group.
2387  /// All the following data will be invalidated.
2388  void instAttribNull()
2390  {
2391  resetGroup<InstAttrib>(
2392  InstAttribAccess(),
2393  *this);
2394  }
2395 
2396  /// Access helper.
2397  struct LotTypeRulesAccess
2398  {
2399  LotTypeRules
2400  operator()(
2401  const InstrumentDefinitionFixedIncome57& obj) const
2403  {
2404  return obj.
2405  groups().
2406  tail<Events>().
2407  tail<FeedTypes>().
2408  tail<InstAttrib>().
2409  head<LotTypeRules>();
2410  }
2411  };
2412 
2413  /// Reset an instance of the repeating group.
2414  /// All the following data will be invalidated.
2415  void lotTypeRulesNull()
2417  {
2418  resetGroup<LotTypeRules>(
2419  LotTypeRulesAccess(),
2420  *this);
2421  }
2422 };
2423 
2424 /// MDInstrumentDefinitionRepo.
2427 : SbeMessage
2428 {
2429  /// Used template schema.
2431 
2432  /// This type alias.
2434 
2435  /// Message template ID from SBE schema.
2436  enum { TemplateId = 58 };
2437 
2438  /// Number of repeating EventType entries.
2439  /// Entry of EventsEntry repeating group.
2442  <
2444  >
2445  {
2446  /// Base class type.
2447  typedef
2449  <
2451  >
2453 
2454  /// This type alias.
2456 
2457  /// Initializes instance of given
2458  /// version over given memory block.
2460  void* data,
2461  EncodedLength length,
2462  SchemaVersion version)
2463  : Base(data, length, version)
2464  {
2465  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2466  assert(length >= minimalBlockLength(version));
2467  }
2468 
2469  /// Reset all variable-length fields if any.
2472  {
2473  return *this;
2474  }
2475 
2476  /// Reset all variable-length and optional fields if any.
2477  ThisType& reset()
2479  {
2480  resetVariableFields();
2481  return *this;
2482  }
2483 
2484  /// Code to represent the type of event.
2488  {
2490 
2491  return enumeration<EventType>(offset);
2492  }
2493 
2494  /// Code to represent the type of event.
2497  {
2499 
2500  setEnumeration<EventType>(offset, value);
2501  return *this;
2502  }
2503 
2504  /// Date and Time of Instrument Activation or Expiration event
2505  /// sent as number of nanoseconds since Unix epoch.
2509  {
2511 
2512  return ordinary<Timestamp>(offset);
2513  }
2514 
2515  /// Date and Time of Instrument Activation or Expiration event
2516  /// sent as number of nanoseconds since Unix epoch.
2517  ThisType& setEventTime(Timestamp value)
2519  {
2521 
2522  setOrdinary(offset, value.sinceEpoch());
2523  return *this;
2524  }
2525 
2526  /// \return size of entry body in bytes
2527  /// for given version of message template.
2532  {
2533  return
2534  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2535  minimalBlockLength(version);
2536  }
2537 
2538  /// \return minimal size of entry body in bytes
2539  /// for given version of message template.
2542  static
2543  BlockLength
2547  {
2548  return
2549  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2550  9;
2551  }
2552 
2553  /// Entity class name.
2557  static const Char* className()
2558  {
2559  return "InstrumentDefinitionRepo58.EventsEntry";
2560  }
2561  };
2562 
2563  /// Repeating group containing EventsEntry entries.
2564  typedef
2567 
2568  /// Number of repeating FeedType repeating group entries.
2569  /// Entry of FeedTypesEntry repeating group.
2572  <
2574  >
2575  {
2576  /// Base class type.
2577  typedef
2579  <
2581  >
2583 
2584  /// This type alias.
2586 
2587  /// Initializes instance of given
2588  /// version over given memory block.
2590  void* data,
2591  EncodedLength length,
2592  SchemaVersion version)
2593  : Base(data, length, version)
2594  {
2595  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2596  assert(length >= minimalBlockLength(version));
2597  }
2598 
2599  /// Reset all variable-length fields if any.
2602  {
2603  return *this;
2604  }
2605 
2606  /// Reset all variable-length and optional fields if any.
2607  ThisType& reset()
2609  {
2610  resetVariableFields();
2611  return *this;
2612  }
2613 
2614  /// Describes a class of service for a given data feed. GBX-
2615  /// Real Book, GBI-Implied Book.
2619  {
2622 
2623  return fixedStr<length>(offset);
2624  }
2625 
2626  /// Describes a class of service for a given data feed. GBX-
2627  /// Real Book, GBI-Implied Book.
2628  ThisType& setFeedType(StrRef value)
2630  {
2633 
2634  setFixedStr<length>(offset, value);
2635  return *this;
2636  }
2637 
2638  /// Book depth.
2642  {
2644 
2645  return ordinary<Int8>(offset);
2646  }
2647 
2648  /// Book depth.
2649  ThisType& setMarketDepth(Int8 value)
2651  {
2653 
2654  setOrdinary(offset, value);
2655  return *this;
2656  }
2657 
2658  /// \return size of entry body in bytes
2659  /// for given version of message template.
2664  {
2665  return
2666  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2667  minimalBlockLength(version);
2668  }
2669 
2670  /// \return minimal size of entry body in bytes
2671  /// for given version of message template.
2674  static
2675  BlockLength
2679  {
2680  return
2681  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2682  4;
2683  }
2684 
2685  /// Entity class name.
2689  static const Char* className()
2690  {
2691  return "InstrumentDefinitionRepo58.FeedTypesEntry";
2692  }
2693  };
2694 
2695  /// Repeating group containing FeedTypesEntry entries.
2696  typedef
2699 
2700  /// Number of repeating InstrAttribType entries.
2701  /// Entry of InstAttribEntry repeating group.
2704  <
2706  >
2707  {
2708  /// Base class type.
2709  typedef
2711  <
2713  >
2715 
2716  /// This type alias.
2718 
2719  /// Initializes instance of given
2720  /// version over given memory block.
2722  void* data,
2723  EncodedLength length,
2724  SchemaVersion version)
2725  : Base(data, length, version)
2726  {
2727  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2728  assert(length >= minimalBlockLength(version));
2729  }
2730 
2731  /// Reset all variable-length fields if any.
2734  {
2735  return *this;
2736  }
2737 
2738  /// Reset all variable-length and optional fields if any.
2739  ThisType& reset()
2741  {
2742  resetVariableFields();
2743  return *this;
2744  }
2745 
2746  /// Instrument eligibility attributes.
2751  {
2752  return InstAttribType();
2753  }
2754 
2755  /// Bitmap field of 32 Boolean type indicators.
2759  {
2761 
2762  return ordinary<InstAttribValue>(offset);
2763  }
2764 
2765  /// Bitmap field of 32 Boolean type indicators.
2768  {
2770 
2771  setOrdinary(offset, value);
2772  return *this;
2773  }
2774 
2775  /// \return size of entry body in bytes
2776  /// for given version of message template.
2781  {
2782  return
2783  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2784  minimalBlockLength(version);
2785  }
2786 
2787  /// \return minimal size of entry body in bytes
2788  /// for given version of message template.
2791  static
2792  BlockLength
2796  {
2797  return
2798  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2799  4;
2800  }
2801 
2802  /// Entity class name.
2806  static const Char* className()
2807  {
2808  return "InstrumentDefinitionRepo58.InstAttribEntry";
2809  }
2810  };
2811 
2812  /// Repeating group containing InstAttribEntry entries.
2813  typedef
2816 
2817  /// Number of entries.
2818  /// Entry of LotTypeRulesEntry repeating group.
2821  <
2823  >
2824  {
2825  /// Base class type.
2826  typedef
2828  <
2830  >
2832 
2833  /// This type alias.
2835 
2836  /// Initializes instance of given
2837  /// version over given memory block.
2839  void* data,
2840  EncodedLength length,
2841  SchemaVersion version)
2842  : Base(data, length, version)
2843  {
2844  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2845  assert(length >= minimalBlockLength(version));
2846  }
2847 
2848  /// Reset all variable-length fields if any.
2851  {
2852  return *this;
2853  }
2854 
2855  /// Reset all variable-length and optional fields if any.
2856  ThisType& reset()
2858  {
2859  minLotSizeNull();
2860 
2861  resetVariableFields();
2862  return *this;
2863  }
2864 
2865  /// This tag is required to interpret the value in tag
2866  /// 1231-MinLotSize.
2868  Int8 lotType() const
2870  {
2872 
2873  return ordinary<Int8>(offset);
2874  }
2875 
2876  /// This tag is required to interpret the value in tag
2877  /// 1231-MinLotSize.
2878  ThisType& setLotType(Int8 value)
2880  {
2882 
2883  setOrdinary(offset, value);
2884  return *this;
2885  }
2886 
2887  /// Minimum quantity accepted for order entry. If tag
2888  /// 1093-LotType=4, this value is the minimum quantity for
2889  /// order entry expressed in the applicable units, specified
2890  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
2891  /// 1093-LotType=5, this value represents order qty increment.
2893  bool minLotSize(DecimalQty& value) const
2895  {
2897 
2898  return decimal(value, offset, NullDecimalQty());
2899  }
2900 
2901  /// Minimum quantity accepted for order entry. If tag
2902  /// 1093-LotType=4, this value is the minimum quantity for
2903  /// order entry expressed in the applicable units, specified
2904  /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
2905  /// 1093-LotType=5, this value represents order qty increment.
2906  ThisType& setMinLotSize(DecimalQty value)
2908  {
2910 
2911  setOrdinary(offset, value);
2912  return *this;
2913  }
2914 
2915  ThisType& minLotSizeNull()
2917  {
2919 
2920  setOrdinary(offset, NullDecimalQty());
2921  return *this;
2922  }
2923 
2924  /// \return size of entry body in bytes
2925  /// for given version of message template.
2930  {
2931  return
2932  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2933  minimalBlockLength(version);
2934  }
2935 
2936  /// \return minimal size of entry body in bytes
2937  /// for given version of message template.
2940  static
2941  BlockLength
2945  {
2946  return
2947  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2948  5;
2949  }
2950 
2951  /// Entity class name.
2955  static const Char* className()
2956  {
2957  return "InstrumentDefinitionRepo58.LotTypeRulesEntry";
2958  }
2959  };
2960 
2961  /// Repeating group containing LotTypeRulesEntry entries.
2962  typedef
2965 
2966  /// Number of underlying entries.
2967  /// Entry of UnderlyingsEntry repeating group.
2970  <
2972  >
2973  {
2974  /// Base class type.
2975  typedef
2977  <
2979  >
2981 
2982  /// This type alias.
2984 
2985  /// Initializes instance of given
2986  /// version over given memory block.
2988  void* data,
2989  EncodedLength length,
2990  SchemaVersion version)
2991  : Base(data, length, version)
2992  {
2993  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2994  assert(length >= minimalBlockLength(version));
2995  }
2996 
2997  /// Reset all variable-length fields if any.
3000  {
3001  return *this;
3002  }
3003 
3004  /// Reset all variable-length and optional fields if any.
3005  ThisType& reset()
3007  {
3008  underlyingSecurityIdNull();
3009  underlyingSecurityAltIdSourceNull();
3010  underlyingMaxLifeTimeNull();
3011  underlyingMinDaysToMaturityNull();
3012  underlyingInstrumentGUIdNull();
3013  underlyingMaturityDateNull();
3014 
3015  resetVariableFields();
3016  return *this;
3017  }
3018 
3019  /// Underlying Instrument Symbol (Short Name). When the
3020  /// underlying is a Globex listed Fixed Income instrument this
3021  /// value will be the same as that contained in Security
3022  /// Definition Tag 55-Symbol of the underlying instrument.
3026  {
3029 
3030  return fixedStr<length>(offset);
3031  }
3032 
3033  /// Underlying Instrument Symbol (Short Name). When the
3034  /// underlying is a Globex listed Fixed Income instrument this
3035  /// value will be the same as that contained in Security
3036  /// Definition Tag 55-Symbol of the underlying instrument.
3037  ThisType& setUnderlyingSymbol(StrRef value)
3039  {
3042 
3043  setFixedStr<length>(offset, value);
3044  return *this;
3045  }
3046 
3047  /// Underlying Security ID as qualified by tag
3048  /// 305-UnderlyingSecurityIDSource. Provided only if the
3049  /// underlying is a Globex listed instrument, this value will
3050  /// be the same as that contained in Security Definition Tag
3051  /// 48-SecurityID.
3053  bool underlyingSecurityId(Int32& value) const
3055  {
3057 
3058  return ordinary(value, offset, NullInt32());
3059  }
3060 
3061  /// Underlying Security ID as qualified by tag
3062  /// 305-UnderlyingSecurityIDSource. Provided only if the
3063  /// underlying is a Globex listed instrument, this value will
3064  /// be the same as that contained in Security Definition Tag
3065  /// 48-SecurityID.
3068  {
3070 
3071  setOrdinary(offset, value);
3072  return *this;
3073  }
3074 
3077  {
3079 
3080  setOrdinary(offset, NullInt32());
3081  return *this;
3082  }
3083 
3084  /// Identifies the class or source of UnderlyingSecurityID Tag
3085  /// 309 value. Always '8' for CME assigned IDs.
3090  {
3091  return SecurityIDSource();
3092  }
3093 
3094  /// Underlying Alternate Security identifier value as
3095  /// qualified by Tag 305-UnderlyingSecuityAltIDSource (e.g.
3096  /// CUSIP, ISIN, etc). For Repo special will contain
3097  /// underlying CUSIP or ISIN. For GC Repo may contain a
3098  /// synthetic CUSIP or ISIN representing a basket.
3102  {
3105 
3106  return fixedStr<length>(offset);
3107  }
3108 
3109  /// Underlying Alternate Security identifier value as
3110  /// qualified by Tag 305-UnderlyingSecuityAltIDSource (e.g.
3111  /// CUSIP, ISIN, etc). For Repo special will contain
3112  /// underlying CUSIP or ISIN. For GC Repo may contain a
3113  /// synthetic CUSIP or ISIN representing a basket.
3116  {
3119 
3120  setFixedStr<length>(offset, value);
3121  return *this;
3122  }
3123 
3124  /// Identifies class or source of the UnderlyingSecurityAltID
3125  /// (458) value.
3127  bool
3129  SecurityAltIDSource::Enum& value) const
3131  {
3133 
3134  return enumeration<SecurityAltIDSource>(value, offset, NullUInt8());
3135  }
3136 
3137  /// Identifies class or source of the UnderlyingSecurityAltID
3138  /// (458) value.
3139  ThisType&
3143  {
3145 
3146  setEnumeration<SecurityAltIDSource>(offset, value);
3147  return *this;
3148  }
3149 
3152  {
3154 
3155  setOrdinary(offset, NullUInt8());
3156  return *this;
3157  }
3158 
3159  /// Long Name of the Underlying Instrument. For the
3160  /// instruments listed on Globex this value will be the same
3161  /// as of that contained in Security Definition Tag
3162  /// 2714-FinancialInstrumentFullName.
3166  {
3169 
3170  return fixedStr<length>(offset);
3171  }
3172 
3173  /// Long Name of the Underlying Instrument. For the
3174  /// instruments listed on Globex this value will be the same
3175  /// as of that contained in Security Definition Tag
3176  /// 2714-FinancialInstrumentFullName.
3179  {
3182 
3183  setFixedStr<length>(offset, value);
3184  return *this;
3185  }
3186 
3187  /// Underlying Security Type.
3191  {
3194 
3195  return fixedStr<length>(offset);
3196  }
3197 
3198  /// Underlying Security Type.
3201  {
3204 
3205  setFixedStr<length>(offset, value);
3206  return *this;
3207  }
3208 
3209  /// Underlying Security's CountryOfIssue. See CountryOfIssue
3210  /// (470) field for description.
3214  {
3217 
3218  return fixedStr<length>(offset);
3219  }
3220 
3221  /// Underlying Security's CountryOfIssue. See CountryOfIssue
3222  /// (470) field for description.
3225  {
3228 
3229  setFixedStr<length>(offset, value);
3230  return *this;
3231  }
3232 
3233  /// Underlying Security's Issuer. See Tag 106-Issuer field for
3234  /// description.
3238  {
3241 
3242  return fixedStr<length>(offset);
3243  }
3244 
3245  /// Underlying Security's Issuer. See Tag 106-Issuer field for
3246  /// description.
3247  ThisType& setUnderlyingIssuer(StrRef value)
3249  {
3252 
3253  setFixedStr<length>(offset, value);
3254  return *this;
3255  }
3256 
3257  /// Max life time of the underlying instruments qualifying for
3258  /// the GC basket in number of year. Will contain null value
3259  /// for Repo specials.
3261  bool underlyingMaxLifeTime(UInt8& value) const
3263  {
3265 
3266  return ordinary(value, offset, NullUInt8());
3267  }
3268 
3269  /// Max life time of the underlying instruments qualifying for
3270  /// the GC basket in number of year. Will contain null value
3271  /// for Repo specials.
3274  {
3276 
3277  setOrdinary(offset, value);
3278  return *this;
3279  }
3280 
3283  {
3285 
3286  setOrdinary(offset, NullUInt8());
3287  return *this;
3288  }
3289 
3290  /// Minimum days to maturity remaining of the underlying
3291  /// instruments to qualify for GC basket. Will contain null
3292  /// value for Repo specials.
3296  {
3298 
3299  return ordinary(value, offset, NullUInt16());
3300  }
3301 
3302  /// Minimum days to maturity remaining of the underlying
3303  /// instruments to qualify for GC basket. Will contain null
3304  /// value for Repo specials.
3307  {
3309 
3310  setOrdinary(offset, value);
3311  return *this;
3312  }
3313 
3316  {
3318 
3319  setOrdinary(offset, NullUInt16());
3320  return *this;
3321  }
3322 
3323  /// Underlying GUID. For Repo specials populated with
3324  /// individual instrument GUID of the underlying security.
3328  {
3330 
3331  return ordinary(value, offset, NullUInt64());
3332  }
3333 
3334  /// Underlying GUID. For Repo specials populated with
3335  /// individual instrument GUID of the underlying security.
3338  {
3340 
3341  setOrdinary(offset, value);
3342  return *this;
3343  }
3344 
3347  {
3349 
3350  setOrdinary(offset, NullUInt64());
3351  return *this;
3352  }
3353 
3354  /// Underlying Security's Maturity Date. Will be populated
3355  /// with Maturity Date of the underlying security instrument
3356  /// for Repo Specials only.
3360  {
3361  typedef LocalMktDate FieldValue;
3362 
3364 
3365  FieldValue fieldValue;
3366 
3367  if (ordinary(fieldValue, offset, NullLocalMktDate()))
3368  {
3369  value = localMktDateToTimestamp(fieldValue);
3370  return true;
3371  }
3372  return false;
3373  }
3374 
3375  /// Underlying Security's Maturity Date. Will be populated
3376  /// with Maturity Date of the underlying security instrument
3377  /// for Repo Specials only.
3380  {
3382 
3383  setOrdinary(offset, timestampToLocalMktDate(value));
3384  return *this;
3385  }
3386 
3389  {
3391 
3392  setOrdinary(offset, NullLocalMktDate());
3393  return *this;
3394  }
3395 
3396  /// \return size of entry body in bytes
3397  /// for given version of message template.
3402  {
3403  return
3404  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3405  minimalBlockLength(version);
3406  }
3407 
3408  /// \return minimal size of entry body in bytes
3409  /// for given version of message template.
3412  static
3413  BlockLength
3417  {
3418  return
3419  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3420  118;
3421  }
3422 
3423  /// Entity class name.
3427  static const Char* className()
3428  {
3429  return "InstrumentDefinitionRepo58.UnderlyingsEntry";
3430  }
3431  };
3432 
3433  /// Repeating group containing UnderlyingsEntry entries.
3434  typedef
3437 
3438  /// Number of related instruments group.
3439  /// Entry of RelatedInstrumentsEntry repeating group.
3442  <
3444  >
3445  {
3446  /// Base class type.
3447  typedef
3449  <
3451  >
3453 
3454  /// This type alias.
3456 
3457  /// Initializes instance of given
3458  /// version over given memory block.
3460  void* data,
3461  EncodedLength length,
3462  SchemaVersion version)
3463  : Base(data, length, version)
3464  {
3465  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
3466  assert(length >= minimalBlockLength(version));
3467  }
3468 
3469  /// Reset all variable-length fields if any.
3472  {
3473  return *this;
3474  }
3475 
3476  /// Reset all variable-length and optional fields if any.
3477  ThisType& reset()
3479  {
3480  relatedInstrumentGUIdNull();
3481 
3482  resetVariableFields();
3483  return *this;
3484  }
3485 
3486  /// Related Security ID. For regular Repo contract will
3487  /// contain SecurityID of AoN Repo for the same underlying
3488  /// product, term, start and end dates. And vice versa - for
3489  /// AoN Repo will contain the related regular Repo SecurityID.
3493  {
3495 
3496  return ordinary<Int32>(offset);
3497  }
3498 
3499  /// Related Security ID. For regular Repo contract will
3500  /// contain SecurityID of AoN Repo for the same underlying
3501  /// product, term, start and end dates. And vice versa - for
3502  /// AoN Repo will contain the related regular Repo SecurityID.
3503  ThisType& setRelatedSecurityId(Int32 value)
3505  {
3507 
3508  setOrdinary(offset, value);
3509  return *this;
3510  }
3511 
3512  /// Related Security ID Source.
3517  {
3518  return SecurityIDSource();
3519  }
3520 
3521  /// Related Instrument Symbol.
3525  {
3528 
3529  return fixedStr<length>(offset);
3530  }
3531 
3532  /// Related Instrument Symbol.
3533  ThisType& setRelatedSymbol(StrRef value)
3535  {
3538 
3539  setFixedStr<length>(offset, value);
3540  return *this;
3541  }
3542 
3543  /// Related Instrument GUID.
3545  bool relatedInstrumentGUId(UInt64& value) const
3547  {
3549 
3550  return ordinary(value, offset, NullUInt64());
3551  }
3552 
3553  /// Related Instrument GUID.
3556  {
3558 
3559  setOrdinary(offset, value);
3560  return *this;
3561  }
3562 
3565  {
3567 
3568  setOrdinary(offset, NullUInt64());
3569  return *this;
3570  }
3571 
3572  /// \return size of entry body in bytes
3573  /// for given version of message template.
3578  {
3579  return
3580  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3581  minimalBlockLength(version);
3582  }
3583 
3584  /// \return minimal size of entry body in bytes
3585  /// for given version of message template.
3588  static
3589  BlockLength
3593  {
3594  return
3595  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3596  32;
3597  }
3598 
3599  /// Entity class name.
3603  static const Char* className()
3604  {
3605  return "InstrumentDefinitionRepo58.RelatedInstrumentsEntry";
3606  }
3607  };
3608 
3609  /// Repeating group containing RelatedInstrumentsEntry entries.
3610  typedef
3613 
3614  /// This group indicates the number of broken dates and
3615  /// references individual broken contracts in user defined
3616  /// tailor made repo. Applicable only to tailor made repos
3617  /// requested by traders with broken dates.
3618  /// Entry of BrokenDatesEntry repeating group.
3621  <
3623  >
3624  {
3625  /// Base class type.
3626  typedef
3628  <
3630  >
3632 
3633  /// This type alias.
3635 
3636  /// Available since version.
3637  enum { SinceVersion = 13 };
3638 
3639  /// Initializes instance of given
3640  /// version over given memory block.
3642  void* data,
3643  EncodedLength length,
3644  SchemaVersion version)
3645  : Base(data, length, version)
3646  {
3647  assert(version >= SinceVersion);
3648  assert(length >= minimalBlockLength(version));
3649  }
3650 
3651  /// Reset all variable-length fields if any.
3654  {
3655  return *this;
3656  }
3657 
3658  /// Reset all variable-length and optional fields if any.
3659  ThisType& reset()
3661  {
3662  brokenDateStartNull();
3663  brokenDateEndNull();
3664 
3665  resetVariableFields();
3666  return *this;
3667  }
3668 
3669  /// External unique broken date Instrument ID.
3673  {
3675 
3676  return ordinary<UInt64>(offset);
3677  }
3678 
3679  /// External unique broken date Instrument ID.
3680  ThisType& setBrokenDateGUId(UInt64 value)
3682  {
3684 
3685  setOrdinary(offset, value);
3686  return *this;
3687  }
3688 
3689  /// Broken date Instrument Globex Security ID.
3693  {
3695 
3696  return ordinary<Int32>(offset);
3697  }
3698 
3699  /// Broken date Instrument Globex Security ID.
3702  {
3704 
3705  setOrdinary(offset, value);
3706  return *this;
3707  }
3708 
3709  /// Start date of a broken date period.
3711  bool brokenDateStart(Timestamp& value) const
3713  {
3714  typedef LocalMktDate FieldValue;
3715 
3717 
3718  FieldValue fieldValue;
3719 
3720  if (ordinary(fieldValue, offset, NullLocalMktDate()))
3721  {
3722  value = localMktDateToTimestamp(fieldValue);
3723  return true;
3724  }
3725  return false;
3726  }
3727 
3728  /// Start date of a broken date period.
3731  {
3733 
3734  setOrdinary(offset, timestampToLocalMktDate(value));
3735  return *this;
3736  }
3737 
3740  {
3742 
3743  setOrdinary(offset, NullLocalMktDate());
3744  return *this;
3745  }
3746 
3747  /// End date of a broken date period.
3749  bool brokenDateEnd(Timestamp& value) const
3751  {
3752  typedef LocalMktDate FieldValue;
3753 
3755 
3756  FieldValue fieldValue;
3757 
3758  if (ordinary(fieldValue, offset, NullLocalMktDate()))
3759  {
3760  value = localMktDateToTimestamp(fieldValue);
3761  return true;
3762  }
3763  return false;
3764  }
3765 
3766  /// End date of a broken date period.
3767  ThisType& setBrokenDateEnd(Timestamp value)
3769  {
3771 
3772  setOrdinary(offset, timestampToLocalMktDate(value));
3773  return *this;
3774  }
3775 
3776  ThisType& brokenDateEndNull()
3778  {
3780 
3781  setOrdinary(offset, NullLocalMktDate());
3782  return *this;
3783  }
3784 
3785  /// \return size of entry body in bytes
3786  /// for given version of message template.
3791  {
3792  return
3793  ONIXS_CONFLATEDTCP_ASSERT(version >= SinceVersion),
3794  minimalBlockLength(version);
3795  }
3796 
3797  /// \return minimal size of entry body in bytes
3798  /// for given version of message template.
3801  static
3802  BlockLength
3806  {
3807  return
3808  ONIXS_CONFLATEDTCP_ASSERT(version >= SinceVersion),
3809  16;
3810  }
3811 
3812  /// Entity class name.
3816  static const Char* className()
3817  {
3818  return "InstrumentDefinitionRepo58.BrokenDatesEntry";
3819  }
3820  };
3821 
3822  /// Repeating group containing BrokenDatesEntry entries.
3823  typedef
3826 
3827  /// Initializes a blank instance.
3829 
3830  /// Initializes an instance over the given memory block.
3832  void* data,
3833  EncodedLength length,
3834  SchemaVersion version = Schema::Version)
3835  : SbeMessage(data, length, version)
3836  {
3837  checkVersion<Schema>(version);
3838  checkLength(length, version);
3839  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3840  reset();
3841  }
3842 
3843  /// Initializes an instance over the given memory block
3844  /// With no variable-length fields initialization
3845  /// It is assumed that the user does such an initialization manually.
3847  void* data,
3848  EncodedLength length,
3849  NoFieldsInit,
3850  SchemaVersion version = Schema::Version)
3851  : SbeMessage(data, length, version)
3852  {
3853  checkVersion<Schema>(version);
3854  checkLength(length, version);
3855  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3856  resetVariableFields();
3857  }
3858 
3859  /// Creates an instance over the given memory block.
3861  void* data,
3862  EncodedLength length,
3863  NoInit)
3864  : SbeMessage(data, length)
3865  {
3866  checkCompatibility();
3867  }
3868 
3869  /// Creates an instance over the given SBE message.
3870  explicit
3872  const SbeMessage& message)
3873  : SbeMessage(message)
3874  {
3875  assert(message.valid());
3876 
3877  checkCompatibility();
3878  }
3879 
3880  /// Bitmap field of eight Boolean type indicators reflecting
3881  /// the end of updates for a given Globex event.
3885  {
3887 
3888  return ordinary<MatchEventIndicator>(offset);
3889  }
3890 
3891  /// Bitmap field of eight Boolean type indicators reflecting
3892  /// the end of updates for a given Globex event.
3893  ThisType&
3895  MatchEventIndicator value)
3897  {
3899 
3900  setOrdinary(offset, value);
3901  return *this;
3902  }
3903 
3904  /// Total number of instruments in the Replay loop. Used on
3905  /// Replay Feed only.
3907  bool totNumReports(UInt32& value) const
3909  {
3911 
3912  return ordinary(value, offset, NullUInt32());
3913  }
3914 
3915  /// Total number of instruments in the Replay loop. Used on
3916  /// Replay Feed only.
3917  ThisType& setTotNumReports(UInt32 value)
3919  {
3921 
3922  setOrdinary(offset, value);
3923  return *this;
3924  }
3925 
3926  ThisType& totNumReportsNull()
3928  {
3930 
3931  setOrdinary(offset, NullUInt32());
3932  return *this;
3933  }
3934 
3935  /// Last Security update action on Incremental feed, 'D' or
3936  /// 'M' is used when a mid-week deletion or modification (i.e.
3937  /// extension) occurs.
3942  {
3944 
3945  return enumeration<SecurityUpdateAction>(offset);
3946  }
3947 
3948  /// Last Security update action on Incremental feed, 'D' or
3949  /// 'M' is used when a mid-week deletion or modification (i.e.
3950  /// extension) occurs.
3951  ThisType&
3955  {
3957 
3958  setEnumeration<SecurityUpdateAction>(offset, value);
3959  return *this;
3960  }
3961 
3962  /// Timestamp of when the instrument was last added, modified
3963  /// or deleted. Sent in number of nanoseconds since Unix epoch.
3967  {
3969 
3970  return ordinary<Timestamp>(offset);
3971  }
3972 
3973  /// Timestamp of when the instrument was last added, modified
3974  /// or deleted. Sent in number of nanoseconds since Unix epoch.
3975  ThisType& setLastUpdateTime(Timestamp value)
3977  {
3979 
3980  setOrdinary(offset, value.sinceEpoch());
3981  return *this;
3982  }
3983 
3984  /// Identifies the current state of the instrument.
3986  bool
3988  SecurityTradingStatus::Enum& value) const
3990  {
3992 
3993  return enumeration<SecurityTradingStatus>(value, offset, NullUInt8());
3994  }
3995 
3996  /// Identifies the current state of the instrument.
3997  ThisType&
4001  {
4003 
4004  setEnumeration<SecurityTradingStatus>(offset, value);
4005  return *this;
4006  }
4007 
4010  {
4012 
4013  setOrdinary(offset, NullUInt8());
4014  return *this;
4015  }
4016 
4017  /// The channel ID as defined in the XML Configuration file.
4019  Int16 applId() const
4021  {
4023 
4024  return ordinary<Int16>(offset);
4025  }
4026 
4027  /// The channel ID as defined in the XML Configuration file.
4028  ThisType& setApplId(Int16 value)
4030  {
4032 
4033  setOrdinary(offset, value);
4034  return *this;
4035  }
4036 
4037  /// Identifies the market segment for all CME Globex
4038  /// instruments.
4042  {
4044 
4045  return ordinary<UInt8>(offset);
4046  }
4047 
4048  /// Identifies the market segment for all CME Globex
4049  /// instruments.
4050  ThisType& setMarketSegmentId(UInt8 value)
4052  {
4054 
4055  setOrdinary(offset, value);
4056  return *this;
4057  }
4058 
4059  /// Product complex.
4063  {
4065 
4066  return ordinary<UInt8>(offset);
4067  }
4068 
4069  /// Product complex.
4070  ThisType& setUnderlyingProduct(UInt8 value)
4072  {
4074 
4075  setOrdinary(offset, value);
4076  return *this;
4077  }
4078 
4079  /// Exchange used to identify a security.
4083  {
4086 
4087  return fixedStr<length>(offset);
4088  }
4089 
4090  /// Exchange used to identify a security.
4091  ThisType& setSecurityExchange(StrRef value)
4093  {
4096 
4097  setFixedStr<length>(offset, value);
4098  return *this;
4099  }
4100 
4101  /// Security Group Code.
4105  {
4108 
4109  return fixedStr<length>(offset);
4110  }
4111 
4112  /// Security Group Code.
4113  ThisType& setSecurityGroup(StrRef value)
4115  {
4118 
4119  setFixedStr<length>(offset, value);
4120  return *this;
4121  }
4122 
4123  /// The underlying asset code also known as Product Code.
4125  StrRef asset() const
4127  {
4130 
4131  return fixedStr<length>(offset);
4132  }
4133 
4134  /// The underlying asset code also known as Product Code.
4135  ThisType& setAsset(StrRef value)
4137  {
4140 
4141  setFixedStr<length>(offset, value);
4142  return *this;
4143  }
4144 
4145  /// Instrument Name or Symbol.
4147  StrRef symbol() const
4149  {
4152 
4153  return fixedStr<length>(offset);
4154  }
4155 
4156  /// Instrument Name or Symbol.
4157  ThisType& setSymbol(StrRef value)
4159  {
4162 
4163  setFixedStr<length>(offset, value);
4164  return *this;
4165  }
4166 
4167  /// Unique instrument ID.
4171  {
4173 
4174  return ordinary<Int32>(offset);
4175  }
4176 
4177  /// Unique instrument ID.
4178  ThisType& setSecurityId(Int32 value)
4180  {
4182 
4183  setOrdinary(offset, value);
4184  return *this;
4185  }
4186 
4187  /// Identifies class or source of the SecurityID (Tag 48)
4188  /// value.
4193  {
4194  return SecurityIDSource();
4195  }
4196 
4197  /// Security Type.
4201  {
4204 
4205  return fixedStr<length>(offset);
4206  }
4207 
4208  /// Security Type.
4209  ThisType& setSecurityType(StrRef value)
4211  {
4214 
4215  setFixedStr<length>(offset, value);
4216  return *this;
4217  }
4218 
4219  /// ISO standard instrument categorization code.
4221  StrRef cfiCode() const
4223  {
4226 
4227  return fixedStr<length>(offset);
4228  }
4229 
4230  /// ISO standard instrument categorization code.
4231  ThisType& setCfiCode(StrRef value)
4233  {
4236 
4237  setFixedStr<length>(offset, value);
4238  return *this;
4239  }
4240 
4241  /// Identifies the currency for the instrument traded.
4245  {
4248 
4249  return fixedStr<length>(offset);
4250  }
4251 
4252  /// Identifies the currency for the instrument traded.
4253  ThisType& setCurrency(StrRef value)
4255  {
4258 
4259  setFixedStr<length>(offset, value);
4260  return *this;
4261  }
4262 
4263  /// Identifies currency used for settlement.
4267  {
4270 
4271  return fixedStr<length>(offset);
4272  }
4273 
4274  /// Identifies currency used for settlement.
4275  ThisType& setSettlCurrency(StrRef value)
4277  {
4280 
4281  setFixedStr<length>(offset, value);
4282  return *this;
4283  }
4284 
4285  /// Matching Algorithm - CME assigned values.
4289  {
4291 
4292  return ordinary<CHAR>(offset);
4293  }
4294 
4295  /// Matching Algorithm - CME assigned values.
4296  ThisType& setMatchAlgorithm(CHAR value)
4298  {
4300 
4301  setOrdinary(offset, value);
4302  return *this;
4303  }
4304 
4305  /// The minimum trading volume for a security.
4309  {
4311 
4312  return ordinary<UInt32>(offset);
4313  }
4314 
4315  /// The minimum trading volume for a security.
4316  ThisType& setMinTradeVol(UInt32 value)
4318  {
4320 
4321  setOrdinary(offset, value);
4322  return *this;
4323  }
4324 
4325  /// The maximum trading volume for a security.
4329  {
4331 
4332  return ordinary<UInt32>(offset);
4333  }
4334 
4335  /// The maximum trading volume for a security.
4336  ThisType& setMaxTradeVol(UInt32 value)
4338  {
4340 
4341  setOrdinary(offset, value);
4342  return *this;
4343  }
4344 
4345  /// Minimum constant tick for the instrument.
4349  {
4351 
4352  return decimal<PRICE9>(offset);
4353  }
4354 
4355  /// Minimum constant tick for the instrument.
4356  ThisType& setMinPriceIncrement(PRICE9 value)
4358  {
4360 
4361  setOrdinary(offset, value);
4362  return *this;
4363  }
4364 
4365  /// Contains the multiplier to convert the CME Globex display
4366  /// price to the conventional price.
4370  {
4372 
4373  return decimal<Decimal9>(offset);
4374  }
4375 
4376  /// Contains the multiplier to convert the CME Globex display
4377  /// price to the conventional price.
4378  ThisType& setDisplayFactor(Decimal9 value)
4380  {
4382 
4383  setOrdinary(offset, value);
4384  return *this;
4385  }
4386 
4387  /// Unit of measure for the products' original contract size.
4388  /// This will be populated for all products listed on CME
4389  /// Globex.
4393  {
4396 
4397  return fixedStr<length>(offset);
4398  }
4399 
4400  /// Unit of measure for the products' original contract size.
4401  /// This will be populated for all products listed on CME
4402  /// Globex.
4403  ThisType& setUnitOfMeasure(StrRef value)
4405  {
4408 
4409  setFixedStr<length>(offset, value);
4410  return *this;
4411  }
4412 
4413  /// This field contains the contract size for each instrument.
4414  /// Use in combination with tag 996-UnitofMeasure.
4416  bool unitOfMeasureQty(Decimal9& value) const
4418  {
4420 
4421  return decimal(value, offset, NullDecimal9());
4422  }
4423 
4424  /// This field contains the contract size for each instrument.
4425  /// Use in combination with tag 996-UnitofMeasure.
4428  {
4430 
4431  setOrdinary(offset, value);
4432  return *this;
4433  }
4434 
4437  {
4439 
4440  setOrdinary(offset, NullDecimal9());
4441  return *this;
4442  }
4443 
4444  /// Trading Reference price.
4446  bool tradingReferencePrice(PRICE9& value) const
4448  {
4450 
4451  return decimal(value, offset, NullPRICE9());
4452  }
4453 
4454  /// Trading Reference price.
4457  {
4459 
4460  setOrdinary(offset, value);
4461  return *this;
4462  }
4463 
4466  {
4468 
4469  setOrdinary(offset, NullPRICE9());
4470  return *this;
4471  }
4472 
4473  /// Indicates session date corresponding to the price in tag
4474  /// 1150-TradingReferencePrice.
4476  bool tradingReferenceDate(Timestamp& value) const
4478  {
4479  typedef LocalMktDate FieldValue;
4480 
4482 
4483  FieldValue fieldValue;
4484 
4485  if (ordinary(fieldValue, offset, NullLocalMktDate()))
4486  {
4487  value = localMktDateToTimestamp(fieldValue);
4488  return true;
4489  }
4490  return false;
4491  }
4492 
4493  /// Indicates session date corresponding to the price in tag
4494  /// 1150-TradingReferencePrice.
4497  {
4499 
4500  setOrdinary(offset, timestampToLocalMktDate(value));
4501  return *this;
4502  }
4503 
4506  {
4508 
4509  setOrdinary(offset, NullLocalMktDate());
4510  return *this;
4511  }
4512 
4513  /// Allowable high limit price for the trading day.
4515  bool highLimitPrice(PRICE9& value) const
4517  {
4519 
4520  return decimal(value, offset, NullPRICE9());
4521  }
4522 
4523  /// Allowable high limit price for the trading day.
4524  ThisType& setHighLimitPrice(PRICE9 value)
4526  {
4528 
4529  setOrdinary(offset, value);
4530  return *this;
4531  }
4532 
4535  {
4537 
4538  setOrdinary(offset, NullPRICE9());
4539  return *this;
4540  }
4541 
4542  /// Allowable low limit price for the trading day.
4544  bool lowLimitPrice(PRICE9& value) const
4546  {
4548 
4549  return decimal(value, offset, NullPRICE9());
4550  }
4551 
4552  /// Allowable low limit price for the trading day.
4553  ThisType& setLowLimitPrice(PRICE9 value)
4555  {
4557 
4558  setOrdinary(offset, value);
4559  return *this;
4560  }
4561 
4562  ThisType& lowLimitPriceNull()
4564  {
4566 
4567  setOrdinary(offset, NullPRICE9());
4568  return *this;
4569  }
4570 
4571  /// Differential value for price banding.
4573  bool maxPriceVariation(PRICE9& value) const
4575  {
4577 
4578  return decimal(value, offset, NullPRICE9());
4579  }
4580 
4581  /// Differential value for price banding.
4582  ThisType& setMaxPriceVariation(PRICE9 value)
4584  {
4586 
4587  setOrdinary(offset, value);
4588  return *this;
4589  }
4590 
4593  {
4595 
4596  setOrdinary(offset, NullPRICE9());
4597  return *this;
4598  }
4599 
4600  /// Long name of the instrument.
4604  {
4607 
4608  return fixedStr<length>(offset);
4609  }
4610 
4611  /// Long name of the instrument.
4614  {
4617 
4618  setFixedStr<length>(offset, value);
4619  return *this;
4620  }
4621 
4622  /// Clearing organization.
4626  {
4629 
4630  return fixedStr<length>(offset);
4631  }
4632 
4633  /// Clearing organization.
4636  {
4639 
4640  setFixedStr<length>(offset, value);
4641  return *this;
4642  }
4643 
4644  /// Start date of a financing deal, i.e. the date the buyer
4645  /// pays the seller cash and takes control of the collateral.
4647  bool startDate(Timestamp& value) const
4649  {
4650  typedef LocalMktDate FieldValue;
4651 
4653 
4654  FieldValue fieldValue;
4655 
4656  if (ordinary(fieldValue, offset, NullLocalMktDate()))
4657  {
4658  value = localMktDateToTimestamp(fieldValue);
4659  return true;
4660  }
4661  return false;
4662  }
4663 
4664  /// Start date of a financing deal, i.e. the date the buyer
4665  /// pays the seller cash and takes control of the collateral.
4666  ThisType& setStartDate(Timestamp value)
4668  {
4670 
4671  setOrdinary(offset, timestampToLocalMktDate(value));
4672  return *this;
4673  }
4674 
4675  ThisType& startDateNull()
4677  {
4679 
4680  setOrdinary(offset, NullLocalMktDate());
4681  return *this;
4682  }
4683 
4684  /// End date of a financing deal, i.e. the date the seller
4685  /// reimburses the buyer and takes back control of the
4686  /// collateral.
4688  bool endDate(Timestamp& value) const
4690  {
4691  typedef LocalMktDate FieldValue;
4692 
4694 
4695  FieldValue fieldValue;
4696 
4697  if (ordinary(fieldValue, offset, NullLocalMktDate()))
4698  {
4699  value = localMktDateToTimestamp(fieldValue);
4700  return true;
4701  }
4702  return false;
4703  }
4704 
4705  /// End date of a financing deal, i.e. the date the seller
4706  /// reimburses the buyer and takes back control of the
4707  /// collateral.
4708  ThisType& setEndDate(Timestamp value)
4710  {
4712 
4713  setOrdinary(offset, timestampToLocalMktDate(value));
4714  return *this;
4715  }
4716 
4717  ThisType& endDateNull()
4719  {
4721 
4722  setOrdinary(offset, NullLocalMktDate());
4723  return *this;
4724  }
4725 
4726  /// For Repos the timing or method for terminating the
4727  /// agreement. Term code.
4731  {
4734 
4735  return fixedStr<length>(offset);
4736  }
4737 
4738  /// For Repos the timing or method for terminating the
4739  /// agreement. Term code.
4740  ThisType& setTerminationType(StrRef value)
4742  {
4745 
4746  setFixedStr<length>(offset, value);
4747  return *this;
4748  }
4749 
4750  /// Repo Sub Security Type.
4754  {
4756 
4757  return enumeration<RepoSubType>(offset);
4758  }
4759 
4760  /// Repo Sub Security Type.
4763  {
4765 
4766  setEnumeration<RepoSubType>(offset, value);
4767  return *this;
4768  }
4769 
4770  /// Money or Par indicates if the GC is filled by par amount
4771  /// or by money amount.
4773  bool moneyOrPar(MoneyOrPar::Enum& value) const
4775  {
4777 
4778  return enumeration<MoneyOrPar>(value, offset, NullUInt8());
4779  }
4780 
4781  /// Money or Par indicates if the GC is filled by par amount
4782  /// or by money amount.
4785  {
4787 
4788  setEnumeration<MoneyOrPar>(offset, value);
4789  return *this;
4790  }
4791 
4792  ThisType& moneyOrParNull()
4794  {
4796 
4797  setOrdinary(offset, NullUInt8());
4798  return *this;
4799  }
4800 
4801  /// Max number of substitutions allowed. The value of 0
4802  /// indicates that substitutions are not allowed.
4806  {
4808 
4809  return ordinary<UInt8>(offset);
4810  }
4811 
4812  /// Max number of substitutions allowed. The value of 0
4813  /// indicates that substitutions are not allowed.
4816  {
4818 
4819  setOrdinary(offset, value);
4820  return *this;
4821  }
4822 
4823  /// Price quotation method.
4827  {
4830 
4831  return fixedStr<length>(offset);
4832  }
4833 
4834  /// Price quotation method.
4835  ThisType& setPriceQuoteMethod(StrRef value)
4837  {
4840 
4841  setFixedStr<length>(offset, value);
4842  return *this;
4843  }
4844 
4845  /// User-defined instrument flag.
4849  {
4851 
4852  return ordinary<UserDefinedInstrument>(offset);
4853  }
4854 
4855  /// User-defined instrument flag.
4856  ThisType&
4858  UserDefinedInstrument value)
4860  {
4862 
4863  setOrdinary(offset, value);
4864  return *this;
4865  }
4866 
4867  /// Risk Set identifies the list of instruments sharing credit
4868  /// limits set up.
4870  StrRef riskSet() const
4872  {
4875 
4876  return fixedStr<length>(offset);
4877  }
4878 
4879  /// Risk Set identifies the list of instruments sharing credit
4880  /// limits set up.
4881  ThisType& setRiskSet(StrRef value)
4883  {
4886 
4887  setFixedStr<length>(offset, value);
4888  return *this;
4889  }
4890 
4891  /// MarketSet defines the bilateral relationship and Self
4892  /// Match Prevention configuration for eligible markets.
4896  {
4899 
4900  return fixedStr<length>(offset);
4901  }
4902 
4903  /// MarketSet defines the bilateral relationship and Self
4904  /// Match Prevention configuration for eligible markets.
4905  ThisType& setMarketSet(StrRef value)
4907  {
4910 
4911  setFixedStr<length>(offset, value);
4912  return *this;
4913  }
4914 
4915  /// External unique instrument ID.
4917  bool instrumentGUId(UInt64& value) const
4919  {
4921 
4922  return ordinary(value, offset, NullUInt64());
4923  }
4924 
4925  /// External unique instrument ID.
4926  ThisType& setInstrumentGUId(UInt64 value)
4928  {
4930 
4931  setOrdinary(offset, value);
4932  return *this;
4933  }
4934 
4937  {
4939 
4940  setOrdinary(offset, NullUInt64());
4941  return *this;
4942  }
4943 
4944  /// Full Repo Term Code.
4948  {
4951 
4952  return fixedStr<length>(offset);
4953  }
4954 
4955  /// Full Repo Term Code.
4956  ThisType& setTermCode(StrRef value)
4958  {
4961 
4962  setFixedStr<length>(offset, value);
4963  return *this;
4964  }
4965 
4966  /// Optionally used in tailor made repo contracts and defines
4967  /// the type of broken dates as requested by trader. Null =
4968  /// Not applicable, 0 = Custom, 1 = Quarterly, 2 = Monthly.
4970  bool brokenDateTermType(UInt8& value) const
4972  {
4975 
4976  return ordinary(value, offset, NullUInt8(), since);
4977  }
4978 
4979  /// Optionally used in tailor made repo contracts and defines
4980  /// the type of broken dates as requested by trader. Null =
4981  /// Not applicable, 0 = Custom, 1 = Quarterly, 2 = Monthly.
4982  ThisType& setBrokenDateTermType(UInt8 value)
4983  {
4986 
4987  setOrdinary(offset, value, since);
4988  return *this;
4989  }
4990 
4992  {
4995 
4996  setOrdinary(offset, NullUInt8(), since);
4997  return *this;
4998  }
4999 
5000  /// \return instance of Events repeating group.
5002  Events events() const
5004  {
5005  return getGroup<Events>(EventsAccess(), *this);
5006  }
5007 
5008  /// \return instance of Events repeating group.
5012  {
5013  return getGroup<Events>(EventsAccess(), *this);
5014  }
5015 
5016  /// Setup repeating group with the given number of entries.
5017  /// Sets all optional fields of the group entries to null.
5018  /// \return NoEvents(864) repeating group.
5020  {
5021  return constructGroup<Events>(
5022  EventsAccess(),
5023  length,
5024  *this);
5025  }
5026 
5027  /// Setup repeating group with the given number of entries.
5028  /// \return NoEvents(864) repeating group.
5029  Events
5031  Events::Size length,
5032  NoFieldsInit)
5033  {
5034  return setupGroup<Events>(
5035  EventsAccess(),
5036  length,
5037  *this);
5038  }
5039 
5040  /// \return instance of FeedTypes repeating group.
5044  {
5045  return getGroup<FeedTypes>(FeedTypesAccess(), *this);
5046  }
5047 
5048  /// \return instance of FeedTypes repeating group.
5052  {
5053  return getGroup<FeedTypes>(FeedTypesAccess(), *this);
5054  }
5055 
5056  /// Setup repeating group with the given number of entries.
5057  /// Sets all optional fields of the group entries to null.
5058  /// \return NoMDFeedTypes(1141) repeating group.
5060  {
5061  return constructGroup<FeedTypes>(
5062  FeedTypesAccess(),
5063  length,
5064  *this);
5065  }
5066 
5067  /// Setup repeating group with the given number of entries.
5068  /// \return NoMDFeedTypes(1141) repeating group.
5069  FeedTypes
5071  FeedTypes::Size length,
5072  NoFieldsInit)
5073  {
5074  return setupGroup<FeedTypes>(
5075  FeedTypesAccess(),
5076  length,
5077  *this);
5078  }
5079 
5080  /// \return instance of InstAttrib repeating group.
5084  {
5085  return getGroup<InstAttrib>(
5086  InstAttribAccess(),
5087  *this);
5088  }
5089 
5090  /// \return instance of InstAttrib repeating group.
5094  {
5095  return getGroup<InstAttrib>(
5096  InstAttribAccess(),
5097  *this);
5098  }
5099 
5100  /// Setup repeating group with the given number of entries.
5101  /// Sets all optional fields of the group entries to null.
5102  /// \return NoInstAttrib(870) repeating group.
5104  {
5105  return constructGroup<InstAttrib>(
5106  InstAttribAccess(),
5107  length,
5108  *this);
5109  }
5110 
5111  /// Setup repeating group with the given number of entries.
5112  /// \return NoInstAttrib(870) repeating group.
5113  InstAttrib
5115  InstAttrib::Size length,
5116  NoFieldsInit)
5117  {
5118  return setupGroup<InstAttrib>(
5119  InstAttribAccess(),
5120  length,
5121  *this);
5122  }
5123 
5124  /// \return instance of LotTypeRules repeating group.
5128  {
5129  return getGroup<LotTypeRules>(
5130  LotTypeRulesAccess(),
5131  *this);
5132  }
5133 
5134  /// \return instance of LotTypeRules repeating group.
5138  {
5139  return getGroup<LotTypeRules>(
5140  LotTypeRulesAccess(),
5141  *this);
5142  }
5143 
5144  /// Setup repeating group with the given number of entries.
5145  /// Sets all optional fields of the group entries to null.
5146  /// \return NoLotTypeRules(1234) repeating group.
5147  LotTypeRules
5149  LotTypeRules::Size length)
5150  {
5151  return constructGroup<LotTypeRules>(
5152  LotTypeRulesAccess(),
5153  length,
5154  *this);
5155  }
5156 
5157  /// Setup repeating group with the given number of entries.
5158  /// \return NoLotTypeRules(1234) repeating group.
5159  LotTypeRules
5161  LotTypeRules::Size length,
5162  NoFieldsInit)
5163  {
5164  return setupGroup<LotTypeRules>(
5165  LotTypeRulesAccess(),
5166  length,
5167  *this);
5168  }
5169 
5170  /// \return instance of Underlyings repeating group.
5174  {
5175  return getGroup<Underlyings>(
5176  UnderlyingsAccess(),
5177  *this);
5178  }
5179 
5180  /// \return instance of Underlyings repeating group.
5184  {
5185  return getGroup<Underlyings>(
5186  UnderlyingsAccess(),
5187  *this);
5188  }
5189 
5190  /// Setup repeating group with the given number of entries.
5191  /// Sets all optional fields of the group entries to null.
5192  /// \return NoUnderlyings(711) repeating group.
5194  {
5195  return constructGroup<Underlyings>(
5196  UnderlyingsAccess(),
5197  length,
5198  *this);
5199  }
5200 
5201  /// Setup repeating group with the given number of entries.
5202  /// \return NoUnderlyings(711) repeating group.
5203  Underlyings
5205  Underlyings::Size length,
5206  NoFieldsInit)
5207  {
5208  return setupGroup<Underlyings>(
5209  UnderlyingsAccess(),
5210  length,
5211  *this);
5212  }
5213 
5214  /// \return instance of RelatedInstruments repeating group.
5218  {
5219  return getGroup<RelatedInstruments>(
5220  RelatedInstrumentsAccess(),
5221  *this);
5222  }
5223 
5224  /// \return instance of RelatedInstruments repeating group.
5228  {
5229  return getGroup<RelatedInstruments>(
5230  RelatedInstrumentsAccess(),
5231  *this);
5232  }
5233 
5234  /// Setup repeating group with the given number of entries.
5235  /// Sets all optional fields of the group entries to null.
5236  /// \return NoRelatedInstruments(1647) repeating group.
5239  RelatedInstruments::Size length)
5240  {
5241  return constructGroup<RelatedInstruments>(
5242  RelatedInstrumentsAccess(),
5243  length,
5244  *this);
5245  }
5246 
5247  /// Setup repeating group with the given number of entries.
5248  /// \return NoRelatedInstruments(1647) repeating group.
5251  RelatedInstruments::Size length,
5252  NoFieldsInit)
5253  {
5254  return setupGroup<RelatedInstruments>(
5255  RelatedInstrumentsAccess(),
5256  length,
5257  *this);
5258  }
5259 
5260  /// \return instance of BrokenDates repeating group.
5264  {
5266 
5267  return getGroup<BrokenDates>(
5268  BrokenDatesAccess(),
5269  since,
5270  *this);
5271  }
5272 
5273  /// \return instance of BrokenDates repeating group.
5277  {
5279 
5280  return getGroup<BrokenDates>(
5281  BrokenDatesAccess(),
5282  since,
5283  *this);
5284  }
5285 
5286  /// Setup repeating group with the given number of entries.
5287  /// Sets all optional fields of the group entries to null.
5288  /// \return NoBrokenDates(39026) repeating group.