OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  18.1.1
API documentation
InstrumentSnapshot.h
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable OnixS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #pragma once
21 
27 
28 namespace OnixS
29 {
30  namespace Eurex
31  {
32  namespace MarketData
33  {
34 
35  /// Alternate identifier entry.
36  class ONIXS_EUREX_EMDI_API SecurityAlt : GroupInstance
37  {
38  public:
39 
40  /// Alternate instrument identifier.
42  {
43  StringRef val;
44  return get (Tags::SecurityAltID).toStringRef (val) ? val : StringRef();
45  }
46 
47  /// Security alternate id source.
49  {
50  StringRef val;
51  return get (Tags::SecurityAltIDSource).toStringRef (val) ? val : StringRef();
52  }
53 
54  private:
55  friend class TypedGroup<SecurityAlt>;
56 
57  SecurityAlt (const GroupInstance& groupInstance)
58  : GroupInstance (groupInstance)
59  {
60  }
61  };
62 
63  class SecurityAlts : public TypedGroup<SecurityAlt>
64  {
65  private:
66  explicit
67  SecurityAlts (const Group& group)
68  : TypedGroup<SecurityAlt> (group)
69  {
70  }
71 
72  friend class InstrumentSnapshot;
73  };
74 
75  /// Exposes list of available security types.
76  struct ONIXS_EUREX_EMDI_API SecurityType
77  {
78  enum Enum
79  {
80  /// Used to identify absence of value.
81  Undefined = -1,
82 
83  ///
84  Option = 0,
85 
86  ///
87  Future = 1,
88 
89  ///
90  MultiLegInstrument = 2,
91 
92  ///
93  VarianceFutures = 3,
94 
95  ///
96  TotalReturnFutures = 4,
97 
98  ///
99  CommonStock = 5,
100 
101  ///
102  Bond = 6,
103 
104  ///
105  TradeAtReferencePrice = 7,
106 
107  ///
108  ExchangeTradedFund = 8,
109 
110  ///
111  ExchangeTradedCommodity = 9,
112 
113  ///
114  ExchangeTradedNote = 10,
115 
116  ///
118 
119  ///
121 
122  ///
124 
125  ///
127 
128  ///
129  DigitalAssets
130  };
131  };
132 
133  /// Exposes list of Instrument scope operators.
134  struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
135  {
136  enum Enum
137  {
138  /// Used to identify absence of value.
139  Undefined = -1,
140 
141  ///
142  Include = 0,
143  };
144  };
145 
146  ///
147  struct ONIXS_EUREX_EMDI_API DisplayDayOfWeek
148  {
149  enum Enum
150  {
151  /// Used to identify absence of value.
152  Undefined = -1,
153 
154  Monday = 0,
155  Tuesday = 1,
156  Wednesday = 2,
157  Thursday = 3,
158  Friday = 4,
159  Saturday = 5,
160  Sunday = 6
161  };
162  };
163 
164  ///
165  struct ONIXS_EUREX_EMDI_API PutOrCall
166  {
167  enum Enum
168  {
169  /// Used to identify absence of value.
170  Undefined = -1,
171 
172  ///
173  Put = 0,
174 
175  ///
176  Call = 1
177  };
178  };
179 
180 
181  ///
182  struct ONIXS_EUREX_EMDI_API ExerciseStyle
183  {
184  enum Enum
185  {
186  /// Used to identify absence of value.
187  Undefined = -1,
188 
189  ///
190  European = 0,
191 
192  ///
193  American = 1
194  };
195  };
196 
197  struct ONIXS_EUREX_EMDI_API MultilegModel
198  {
199  enum Enum
200  {
201  /// Used to identify absence of value.
202  Undefined = -1,
203 
204  ///
205  PredefinedMultilegSecurity = 0,
206 
207  ///
208  UserDefinedMultilegSecurity = 1
209  };
210  };
211 
212  ///
213  struct ONIXS_EUREX_EMDI_API ValuationMethod
214  {
215  enum Enum
216  {
217  /// Used to identify absence of value.
218  Undefined = -1,
219 
220  ///
221  PremiumStyle = 0,
222 
223  ///
224  FuturesStyleMarkToMarket = 1
225  };
226  };
227 
228  ///
229  struct ONIXS_EUREX_EMDI_API WarrantType
230  {
231  enum Enum
232  {
233  /// Used to identify absence of value.
234  Undefined = -1,
235 
236  ///
237  Call = 0,
238  ///
240  ///
242  ///
244  ///
245  Other
246  };
247  };
248 
249 
250  struct ONIXS_EUREX_EMDI_API SettlMethod
251  {
252  enum Enum
253  {
254  /// Used to identify absence of value.
255  Undefined = -1,
256 
257  ///
258  Cash = 0,
259 
260  ///
261  Physical = 1
262  };
263  };
264 
265  struct ONIXS_EUREX_EMDI_API SettlSubMethod
266  {
267  enum Enum
268  {
269  /// Used to identify absence of value.
270  Undefined = -1,
271 
272  ///
273  Shares = 0,
274  Derivatives = 1,
275  PaymentVsPayment = 2,
276  Notional = 3,
277  Cascade = 4,
278  Other = 5,
279  Energy = 6
280  };
281  };
282 
283  struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
284  {
285  enum Enum
286  {
287  /// Used to identify absence of value.
288  Undefined = -1,
289 
290  ///
291  Proprietary = 0,
292  };
293  };
294 
295  struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
296  {
297  enum Enum
298  {
299  /// Used to identify absence of value.
300  Undefined = -1,
301 
302  ///
303  ClearingOrganization = 0,
304  ///
305  MarketMaker = 1,
306  };
307  };
308 
309  struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
310  {
311  enum Enum
312  {
313  /// Used to identify absence of value.
314  Undefined = -1,
315 
316  ///
317  DesignatedSponsor = 0,
318 
319  ///
320  Specialist
321  };
322  };
323 
324  /// Deposit Type
325  struct ONIXS_EUREX_EMDI_API DepositType
326  {
327  enum Enum
328  {
329  /// Used to identify absence of value.
330  Undefined = -1,
331 
332  ///
333  Auslandskassenverein = 0,
334 
335  ///
336  Girosammelverwahrung = 1,
337 
338  ///
339  Streifbandverwahrung = 2,
340 
341  ///
342  Wertpapierrechnung = 3,
343 
344  ///
345  NcsCviaT2S = 4
346  };
347  };
348 
349  /// Accrued interest Calculation Methods
350  struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
351  {
352  enum Enum
353  {
354  /// Used to identify absence of value.
355  Undefined = -1,
356 
357  ///
358  Basis30360 = 0,
359 
360  ///
362 
363  ///
365 
366  ///
368 
369  ///
371 
372  ///
374 
375  ///
377 
378  ///
380  };
381  };
382 
383  /// Coupon Types
384  struct ONIXS_EUREX_EMDI_API CouponType
385  {
386  enum Enum
387  {
388  /// Used to identify absence of value.
389  Undefined = -1,
390 
391  ///
392  Zero = 0,
393 
394  ///
396 
397  ///
399 
400  ///
402  };
403  };
404 
405  /// Cover Indicator
406  struct ONIXS_EUREX_EMDI_API CoverIndicator
407  {
408  enum Enum
409  {
410  /// Used to identify absence of value.
411  Undefined = -1,
412 
413  ///
414  Intraday = 0,
415 
416  ///
418 
419  ///
421  };
422  };
423 
424  /// Flat Indicators
425  struct ONIXS_EUREX_EMDI_API FlatIndicator
426  {
427  enum Enum
428  {
429  /// Used to identify absence of value.
430  Undefined = -1,
431 
432  ///
433  NoFlat = 0,
434 
435  ///
437 
438  ///
440  };
441  };
442 
443  ///
444  struct ONIXS_EUREX_EMDI_API ListMethod
445  {
446  enum Enum
447  {
448  /// Used to identify absence of value.
449  Undefined = -1,
450 
451  ///
452  PreListedOnly = 0,
453 
454  ///
456  };
457  };
458 
459  struct ONIXS_EUREX_EMDI_API MaturityFrequencyUnit
460  {
461  enum Enum
462  {
463  /// Used to identify absence of value.
464  Undefined = -1,
465 
466  ///
467  NoValue = 0,
468 
469  ///
470  Day = 1, // D
471 
472  ///
473  Week = 2, // Wk
474 
475  ///
476  Month = 3, // Mo
477 
478  ///
479  Flexible = 4, // F
480 
481  ///
482  EndOfMonth = 5, // EOM
483  };
484 
485  static std::string toString (Enum value);
486  };
487 
488  /// Instrument Party.
489  class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
490  {
491  public:
492 
493  /// Identifies a party associated with an instrument.
494  StringRef id() const
495  {
496  StringRef val;
497  return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
498  }
499 
500  ///
502  {
503  return getIntEnumFieldValue<InstrumentPartyIDSource> (*this, Tags::InstrumentPartyIDSource);
504  }
505 
506  ///
508  {
509  return getIntEnumFieldValue<InstrumentPartyRole> (*this, Tags::InstrumentPartyRole);
510  }
511 
512  ///
514  {
515  return getIntEnumFieldValue<InstrumentPartyRoleQualifier> (*this, Tags::InstrumentPartyRoleQualifier);
516  }
517 
518  private:
520 
521  InstrumentParty (const GroupInstance& groupInstance)
522  : GroupInstance (groupInstance)
523  {
524  }
525  };
526 
527  struct ONIXS_EUREX_EMDI_API InstrumentAttributeType
528  {
529  enum Enum
530  {
531  /// Used to identify absence of value.
532  Undefined = -1,
533 
534  ///
535  MinimumReserveOrderQuantity = 0,
536  ///
537  MinimumDisplayQuantity = 1,
538  ///
539  IssuerName = 2,
540  ///
541  IssuerNumber = 3,
542  ///
543  MarketType = 4,
544  ///
545  MarketTypeSupplement = 5,
546  ///
547  ReportingMarket = 6,
548  ///
549  CumExIndicator = 7,
550  ///
551  ProductAssignmentGroup = 8,
552  ///
553  ProductAssignmentGroupDescription = 9,
554  ///
555  PreTradeLISValue = 10,
556  ///
557  VDOMinimumExecutionVolume = 11,
558  ///
559  IlliquidAsDefinedByExchange = 12,
560  ///
561  MarketMakingObligation = 13,
562  ///
563  LiquidAsDefinedByRegulator = 14,
564  ///
565  EligibleForStressedMarketConditions = 15,
566  ///
568  ///
570  ///
572  ///
574  ///
576  ///
578  ///
580  ///
582  ///
584  ///
586  ///
588  ///
590  ///
591  LiquidityClass
592  };
593  };
594 
595  struct ONIXS_EUREX_EMDI_API EventType
596  {
597  enum Enum
598  {
599  /// Used to identify absence of value.
600  Undefined = -1,
601 
602  ///
603  LastEligible = 0,
604 
605  ///
606  FirstEligible = 1,
607 
608  ///
609  CapitalAdjustment = 2,
610 
611  ///
612  DividendPayment = 3,
613 
614  ///
616  };
617  };
618 
619  struct ONIXS_EUREX_EMDI_API InstrumentAuctionType
620  {
621  enum Enum
622  {
623  /// Used to identify absence of value.
624  Undefined = -1,
625 
626  ///
627  Default = 0,
628  ///
629  SingleAuction = 1,
630  ///
631  SpecialAuction = 2
632  };
633  };
634 
635  struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
636  {
637  enum Enum
638  {
639  /// Used to identify absence of value.
640  Undefined = -1,
641 
642  ///
643  Disabled = 0,
644  ///
645  Enabled = 1,
646  ///
647  CentralCounterparty = 2,
648  };
649  };
650 
651  struct ONIXS_EUREX_EMDI_API PriceNotation
652  {
653  enum Enum
654  {
655  /// Used to identify absence of value.
656  Undefined = -1,
657 
658  ///
659  AverageNetChange = 0,
660 
661  ///
662  Average = 1,
663  };
664  };
665 
666  struct ONIXS_EUREX_EMDI_API PriceType
667  {
668  enum Enum
669  {
670  /// Used to identify absence of value.
671  Undefined = -1,
672 
673  ///
674  Percent = 0,
675  ///
676  Shares = 1,
677  ///
678  Points = 2,
679  };
680  };
681 
682  struct ONIXS_EUREX_EMDI_API ContractIdentificationEligibility
683  {
684  enum Enum
685  {
686  /// Used to identify absence of value.
687  Undefined = -1,
688 
689  ///
691 
692  ///
694 
695  ///
697  };
698  };
699 
700  ///
701  struct ONIXS_EUREX_EMDI_API ContractMonthType
702  {
703  enum Enum
704  {
705  /// Used to identify absence of value.
706  Undefined = -1,
707 
708  ///
709  MaturityMonth = 1,
710 
711  ///
713 
714  ///
716 
717  ///
719 
720  ///
722  };
723  };
724 
725 
726  struct ONIXS_EUREX_EMDI_API ContractCycleType
727  {
728  enum Enum
729  {
730  /// Used to identify absence of value.
731  Undefined = -1,
732 
733  ///
734  Dayly = 0,
735 
736  ///
738 
739  ///
741 
742  ///
744 
745  ///
747 
748  ///
750  };
751  };
752 
753  struct ONIXS_EUREX_EMDI_API ContractCycleSubType
754  {
755  enum Enum
756  {
757  /// Used to identify absence of value.
758  Undefined = -1,
759 
760  ///
761  EndOfMonth = 0,
762  };
763  };
764 
765  struct ONIXS_EUREX_EMDI_API ContractFrequency
766  {
767  enum Enum
768  {
769  /// Used to identify absence of value.
770  Undefined = -1,
771 
772  ///
773  Day = 0,
774 
775  ///
777 
778  ///
780 
781  ///
783 
784  ///
785  EndOfMonth
786 
787  };
788  };
789 
790  struct ONIXS_EUREX_EMDI_API ContractDisplayInstruction
791  {
792  enum Enum
793  {
794  /// Used to identify absence of value.
795  Undefined = -1,
796 
797  ///
798  None = 0,
799 
800  ///
802 
803  ///
805 
806  ///
808 
809  ///
811 
812  ///
814 
815  ///
817 
818  ///
820 
821  ///
823 
824  ///
826 
827  ///
829 
830  ///
831  EndOfMonth
832  };
833  };
834 
835  struct ONIXS_EUREX_EMDI_API DisplaySeason
836  {
837  enum Enum
838  {
839  /// Used to identify absence of value.
840  Undefined = -1,
841 
842  ///
843  Summer = 0,
844 
845  ///
847  };
848  };
849 
850  class InstrumentParties : public TypedGroup<InstrumentParty>
851  {
852  private:
853  explicit
854  InstrumentParties (const Group& group)
856  {
857  }
858 
859  friend class InstrumentSnapshot;
860  };
861 
862  /// Instrument Attribute.
863  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
864  {
865  public:
866 
867  ///
869  {
870  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
871  }
872 
873  ///
874  StringRef value() const
875  {
876  StringRef val;
877  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
878  }
879 
880  private:
882 
883  InstrumentAttribute (const GroupInstance& groupInstance)
884  : GroupInstance (groupInstance)
885  {
886  }
887  };
888 
889  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
890  {
891  private:
892  explicit
893  InstrumentAttributes (const Group& group)
895  {
896  }
897 
898  friend class InstrumentSnapshot;
899  };
900 
901 
902  class ONIXS_EUREX_EMDI_API SecurityClassification : GroupInstance
903  {
904  public:
905  ///
907  {
908  return getIntEnumFieldValue<SecurityClassificationReasonType> (*this, Tags::SecurityClassificationReason);
909  }
910 
911  ///
913  {
914  return getIntEnumFieldValue<SecurityClassificationValueType> (*this, Tags::SecurityClassificationValue);
915  }
916 
917  private:
919 
920  SecurityClassification (const GroupInstance& groupInstance)
921  : GroupInstance (groupInstance)
922  {
923  }
924  };
925 
926  ///
927  class SecurityClassifications : public TypedGroup<SecurityClassification>
928  {
929  private:
930  explicit
931  SecurityClassifications (const Group& group)
933  {
934  }
935 
936  friend class InstrumentSnapshot;
937  };
938 
939  /// Event.
940  class ONIXS_EUREX_EMDI_API Event : GroupInstance
941  {
942  public:
943  /// Event Type
945  {
946  return getIntEnumFieldValue<EventType>(*this, Tags::EventType);
947  }
948 
949  /// Event Date
951  {
952  return getUInt32 (Tags::EventDate);
953  }
954 
955  private:
956  friend class TypedGroup<Event>;
957 
958  Event (const GroupInstance& groupInstance)
959  : GroupInstance (groupInstance)
960  {
961  }
962  };
963 
964  class Events : public TypedGroup<Event>
965  {
966  private:
967  explicit
968  Events (const Group& group)
969  : TypedGroup<Event> (group)
970  {
971  }
972 
973  friend class InstrumentSnapshot;
974  };
975 
976  ///
977  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
978  {
979  private:
980  explicit
981  InstrumentSnapshotLegs (const Group& group)
982  : TypedGroup<InstrumentLeg> (group)
983  {
984  }
985 
986  friend class InstrumentSnapshot;
987  };
988 
989 
990  /// TradingSessionRules
991  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
992  {
993  public:
994 
995  /// Trading Session ID
997  {
998  return 0u;
999  }
1000 
1001  /// Defines the trading session sub ID.
1003  {
1004  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
1005  }
1006 
1007  private:
1009 
1010  TradingSessionRule (const GroupInstance& groupInstance)
1011  : GroupInstance (groupInstance)
1012  {
1013  }
1014  };
1015 
1016  ///
1017  class TradingSessionRules : public TypedGroup<TradingSessionRule>
1018  {
1019  private:
1020  explicit
1021  TradingSessionRules (const Group& group)
1023  {
1024  }
1025 
1026  friend class InstrumentSnapshot;
1027  };
1028 
1029  /// Instrument snapshot.
1030  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
1031  {
1032  public:
1033  /// Instrument identifier.
1035  {
1036  return getInt64 (Tags::SecurityID);
1037  }
1038 
1039  /// Entries.
1041  {
1042  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
1043  }
1044 
1045  /// Type of security.
1047  {
1048  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
1049  }
1050 
1051  /// Security Status.
1053  {
1054  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
1055  }
1056 
1057  /// Security description
1058  bool securityDesc(StringRef& desc) const
1059  {
1060  return get (Tags::SecurityDesc).toStringRef (desc);
1061  }
1062 
1063  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
1064  bool securityExchange (StringRef& exchange) const
1065  {
1066  return get (Tags::SecurityExchange).toStringRef (exchange);
1067  }
1068 
1069  /// Type of Market Data update action
1071  {
1072  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
1073  }
1074 
1075  /// Indicates the type of security using ISO 10962 standard.
1076  bool cfiCode(StringRef& desc) const
1077  {
1078  return get (Tags::CFICode).toStringRef (desc);
1079  }
1080 
1081  /// Display Name
1082  bool displayName(StringRef& desc) const
1083  {
1084  return get(Tags::DisplayName).toStringRef(desc);
1085  }
1086 
1087  /// Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely within a product.
1089  {
1090  return getIntEnumFieldValue<ContractIdentificationEligibility>(*this, Tags::ContractIdentificationEligibility);
1091  }
1092 
1093  /// Defines, if this contract based on its contract generation cycle, is considered primary.
1094  bool isPrimary() const
1095  {
1096  UInt32 value;
1097  return get(Tags::IsPrimary).toNumber(value) ? (value == 1) : false;
1098  }
1099 
1100  ///
1101  bool quantityScalingFactor(UInt32& value) const
1102  {
1103  return get(Tags::QuantityScalingFactor).toNumber(value);
1104  }
1105 
1106  ///
1108  {
1109  return get (Tags::SecurityReferenceDataSupplement).toNumber (value);
1110  }
1111 
1112  /// Actual contract start date
1113  bool contractDate (UInt32& value) const
1114  {
1115  return get (Tags::ContractDate).toNumber (value);
1116  }
1117 
1118  /// A symbol to describe the type of ContractDate
1119  bool contractDateType(StringRef& value) const
1120  {
1121  return get(Tags::ContractDateType).toStringRef(value);
1122  }
1123 
1124  /// Contract start month
1125  bool contractMonthYear (UInt32& value) const
1126  {
1127  return get (Tags::ContractMonthYear).toNumber (value);
1128  }
1129 
1130  /// Defines the instrument cycle type
1132  {
1133  return getIntEnumFieldValue<ContractMonthType>(*this, Tags::ContractMonthType);
1134  }
1135 
1136  /// Defines the instrument cycle type
1138  {
1139  return getIntEnumFieldValue<ContractCycleType>(*this, Tags::ContractCycleType);
1140  }
1141 
1142  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1144  {
1145  return getIntEnumFieldValue<ContractCycleSubType>(*this, Tags::ContractCycleSubType);
1146  }
1147 
1148  ///
1150  {
1151  return getIntEnumFieldValue<MaturityFrequencyUnit>(*this, Tags::MaturityFrequencyUnit);
1152  }
1153 
1154  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1156  {
1157  return getIntEnumFieldValue<ContractFrequency>(*this, Tags::ContractFrequency);
1158  }
1159 
1160  /// Defines the instrument display instruction
1162  {
1163  return getIntEnumFieldValue<ContractDisplayInstruction>(*this, Tags::ContractDisplayInstruction);
1164  }
1165 
1166  /// Display Day
1167  bool displayDay(UInt32& value) const
1168  {
1169  return get(Tags::DisplayDay).toNumber(value);
1170  }
1171 
1172  /// Display Relative Day
1173  bool displayRelativeDay(Int32& value) const
1174  {
1175  return get(Tags::DisplayRelativeDay).toNumber(value);
1176  }
1177 
1178  /// Display Week
1179  bool displayWeek(UInt32& value) const
1180  {
1181  return get(Tags::DisplayWeek).toNumber(value);
1182  }
1183 
1184  /// The day of week of the weekly contract.
1186  {
1187  return getIntEnumFieldValue<DisplayDayOfWeek>(*this, Tags::DisplayDayOfWeek);
1188  }
1189 
1190  /// Display Month
1191  bool displayMonth(UInt32& value) const
1192  {
1193  return get(Tags::DisplayMonth).toNumber(value);
1194  }
1195 
1196  /// The Display Quarter denotes the three-month period inside a year.
1197  bool displayQuarter(UInt32& value) const
1198  {
1199  return get(Tags::DisplayQuarter).toNumber(value);
1200  }
1201 
1202  /// Defines the instrument display instruction
1204  {
1205  return getIntEnumFieldValue<DisplaySeason>(*this, Tags::DisplaySeason);
1206  }
1207 
1208  /// Display Year
1209  bool displayYear(UInt32& value) const
1210  {
1211  return get(Tags::DisplayYear).toNumber(value);
1212  }
1213 
1214  /// Strike Price
1215  bool strikePrice (Decimal& price) const
1216  {
1217  return get (Tags::StrikePrice).toNumber (price);
1218  }
1219 
1220  /// Strike Price Precision
1221  bool strikePricePrecision (UInt32& precision) const
1222  {
1223  return get (Tags::StrikePricePrecision).toNumber (precision);
1224  }
1225 
1226  /// Contract Multiplier
1227  bool contractMultiplier (Decimal& multiplier) const
1228  {
1229  return get (Tags::ContractMultiplier).toNumber (multiplier);
1230  }
1231 
1232  /// Put Or Call
1234  {
1235  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
1236  }
1237 
1238  /// Version of an option. Version can change as a result of corporate actions or events.
1239  bool optAttribute (UInt32& attribute) const
1240  {
1241  return get (Tags::OptAttribute).toNumber (attribute);
1242  }
1243 
1244  /// Exercise Style
1246  {
1247  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
1248  }
1249 
1250  /// Original strike price prior to corporate action, e.g. 5.20.
1251  bool origStrikePrice (Decimal& price) const
1252  {
1253  return get (Tags::OrigStrikePrice).toNumber (price);
1254  }
1255 
1256  /// Contract generation.
1257  bool contractGenerationNumber (UInt32& number) const
1258  {
1259  return get (Tags::ContractGenerationNumber).toNumber (number);
1260  }
1261 
1262  /// Lepo Flag
1264  {
1265  UInt32 value;
1266  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
1267  }
1268 
1269  /// Traditional or futures margin style.
1271  {
1272  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
1273  }
1274 
1275  ///
1277  {
1278  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
1279  }
1280 
1281  ///
1283  {
1284  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
1285  }
1286 
1287  /// Previous day's settlement price. Converted in trading notation in case of variance futures.
1288  bool priorSettlPrice (Decimal& price) const
1289  {
1290  return get (Tags::PriorSettlPrice).toNumber (price);
1291  }
1292 
1293  /// Previous day's option delta provided for option instruments only.
1294  bool priceDelta(Decimal& value) const
1295  {
1296  return get(Tags::PriceDelta).toNumber(value);
1297  }
1298 
1299  /// Risk Sensitivity Factor
1300  bool riskSensitivityFactor(Decimal& value) const
1301  {
1302  return get(Tags::RiskSensitivityFactor).toNumber(value);
1303  }
1304 
1305  /// Indicates whether this message is the last in a sequence of messages that together convey a joint list of InstrmtLegGrp.
1307  {
1308  return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
1309  }
1310 
1311  /// Common integer multiple of the option legs for Option Volatility Strategies.
1312  bool legRatioMultiplier(UInt32& value) const
1313  {
1314  return get(Tags::LegRatioMultiplier).toNumber(value);
1315  }
1316 
1317  ///
1319  {
1320  return getNonZeroIntEnumFieldValue<PriceNotation> (*this, Tags::PriceNotation);
1321  }
1322 
1323  /// Legs
1325  {
1326  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
1327  }
1328 
1329  /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
1331  {
1332  return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
1333  }
1334 
1335  /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
1336  bool underlyingSecurityID(Int64& val) const
1337  {
1338  return get(Tags::UnderlyingSecurityID).toNumber(val);
1339  }
1340 
1341  /// UnitOfMeasure
1342  bool unitOfMeasure(StringRef& val) const
1343  {
1344  return get(Tags::UnitOfMeasure).toStringRef(val);
1345  }
1346 
1347  /// AssetType
1348  bool assetType(UInt32& val) const
1349  {
1350  return get(Tags::AssetType).toNumber(val);
1351  }
1352 
1353  /// AssetSubType
1354  bool assetSubType(UInt32& val) const
1355  {
1356  return get(Tags::AssetSubType).toNumber(val);
1357  }
1358 
1359  /// Transact Time
1360  bool transactTime (UInt64& time) const
1361  {
1362  return get (Tags::TransactTime).toNumber (time);
1363  }
1364 
1365  /// Reference to tick size table identifier from product level message.
1366  bool refTickTableID (UInt32& time) const
1367  {
1368  return get (Tags::RefTickTableID).toNumber (time);
1369  }
1370 
1371  /// Currency as published in ISO 4217.
1372  bool currency (StringRef& value) const
1373  {
1374  return get (Tags::Currency).toStringRef (value);
1375  }
1376 
1377  /// Settlement currency.
1378  bool settlCurrency(StringRef& desc) const
1379  {
1380  return get (Tags::SettlCurrency).toStringRef (desc);
1381  }
1382 
1383  /// DepositType
1385  {
1386  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
1387  }
1388 
1389  /// Issue date of instrument.
1390  bool issueDate(UInt32& date) const
1391  {
1392  return get(Tags::IssueDate).toNumber(date);
1393  }
1394 
1395  ///
1396  bool roundLot(Decimal& value) const
1397  {
1398  return get(Tags::RoundLot).toNumber(value);
1399  }
1400 
1401  /// The minimum tradable unit of a bond.
1402  bool minTradeVol(Decimal& value) const
1403  {
1404  return get(Tags::MinTradeVol).toNumber(value);
1405  }
1406 
1407  ///
1408  bool maxTradeVol(Decimal& value) const
1409  {
1410  return get(Tags::MaxTradeVol).toNumber(value);
1411  }
1412 
1413  ///
1414  bool maxTradeVal(Decimal& value) const
1415  {
1416  return get(Tags::MaxTradeVal).toNumber(value);
1417  }
1418 
1419  /// QuotingStartTime
1420  bool quotingStartTime(StringRef& value) const
1421  {
1422  return get(Tags::QuotingStartTime).toStringRef(value);
1423  }
1424 
1425  /// QuotingEndTime
1426  bool quotingEndTime(StringRef& value) const
1427  {
1428  return get(Tags::QuotingEndTime).toStringRef(value);
1429  }
1430 
1431  /// InstrumentAuctionType
1433  {
1434  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
1435  }
1436 
1437  /// MidpointTrading
1439  {
1440  return getIntEnumFieldValue<MidpointTrading>(*this, Tags::MidpointTrading);
1441  }
1442 
1443  ///
1445  {
1446  StringRef val;
1447  return get (Tags::MidpointExecVenueID).toStringRef (val) ? val : StringRef();
1448  }
1449 
1450  /// Instrument parties.
1452  {
1453  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
1454  }
1455 
1456  /// Underlying symbol.
1458  {
1459  return getStringRef(Tags::UnderlyingSymbol);
1460  }
1461 
1462  /// Instrument identifier of the leg security.
1463  bool couponRate(Decimal& value) const
1464  {
1465  return get(Tags::CouponRate).toNumber(value);
1466  }
1467 
1468  /// Previous coupon payment date.
1470  {
1471  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
1472  }
1473 
1474  /// Upcoming Coupon payment date.
1475  bool couponPaymentDate(UInt32& value) const
1476  {
1477  return get(Tags::CouponPaymentDate).toNumber(value);
1478  }
1479 
1480  /// Defines the Accrued interest Calculation Method.
1482  {
1483  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
1484  }
1485 
1486  /// Coupon Type
1488  {
1489  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
1490  }
1491 
1492  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
1494  {
1495  return getStringRef(Tags::CountryOfIssue);
1496  }
1497 
1498  /// The Flat Indicator of a bond.
1500  {
1501  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
1502  }
1503 
1504  /// WarrantType
1506  {
1507  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
1508  }
1509 
1510  /// CoverIndicator
1512  {
1513  return getIntEnumFieldValue<CoverIndicator>(*this, Tags::CoverIndicator);
1514  }
1515 
1516  /// Reference to Volatility Corridor Table for Opening Auction
1518  {
1519  return get(Tags::VolatilityCorridorOpeningAuction).toNumber(value);
1520  }
1521 
1522  /// Reference to Volatility Corridor Table for Intraday Auction
1524  {
1525  return get(Tags::VolatilityCorridorIntradayAuction).toNumber(value);
1526  }
1527 
1528  /// Reference to Volatility Corridor Table for Closing Auction
1530  {
1531  return get(Tags::VolatilityCorridorClosingAuction).toNumber(value);
1532  }
1533 
1534  /// Reference to Volatility Corridor Table in Continuous
1536  {
1537  return get(Tags::VolatilityCorridorContinuous).toNumber(value);
1538  }
1539 
1540  /// Instrument attributes
1542  {
1543  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1544  }
1545 
1546  /// Events.
1547  Events events() const
1548  {
1549  return Events ( getGroup (Tags::NoEvents) );
1550  }
1551 
1552  /// Instrument Price Precision
1553  bool instrumentPricePrecision (UInt32& value) const
1554  {
1555  return get (Tags::InstrumentPricePrecision).toNumber (value);
1556  }
1557 
1558  /// Defines the minimum price movement in ticks (tick size).
1559  bool minPriceIncrement (Decimal& increment) const
1560  {
1561  return get (Tags::MinPriceIncrement).toNumber (increment);
1562  }
1563 
1564  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1566  {
1567  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1568  }
1569 
1570  /// Defines the minimum price movement in the respective currency (tick value).
1572  {
1573  return get (Tags::MinPriceIncrementAmount).toNumber (value);
1574  }
1575 
1576  /// Actual expiration day of the instrument (YYYYMMDD).
1577  bool maturityDate(Timestamp& date) const
1578  {
1579  UInt32 tmp;
1580  if (get(Tags::MaturityDate).toNumber(tmp))
1581  {
1583  return true;
1584  }
1585  return false;
1586  }
1587 
1588  /// Expiration month (YYYYMM).
1589  bool maturityMonthYear(UInt32& monthYear) const
1590  {
1591  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1592  }
1593 
1594  /// Standard strategy type for complex instruments.
1595  bool securitySubType(UInt32& type) const
1596  {
1597  return get(Tags::SecuritySubType).toNumber(type);
1598  }
1599 
1600  ///
1601  bool relatedSecurityId(Int64& value) const
1602  {
1603  return get(Tags::RelatedSecurityID).toNumber(value);
1604  }
1605 
1606  ///
1608  {
1609  return StringRef("M");
1610  }
1611 
1612  /// Product identifier.
1614  {
1615  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1616  }
1617 
1618  /// Implied market indicator
1620  {
1621  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1622  }
1623 
1624  /// Multileg model
1626  {
1627  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1628  }
1629 
1630  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1632  {
1633  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1634  }
1635 
1636  /// Only for cash.
1638  {
1639  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1640  }
1641 
1642  /// Settlement Business Days
1643  bool settlBusinessDays (UInt32& value) const
1644  {
1645  return get (Tags::SettlBusinessDays).toNumber (value);
1646  }
1647 
1648  /// Bid side minimum quote quantity.
1650  {
1651  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1652  }
1653 
1654  /// Bid side minimum quote quantity.
1655  bool quoteSizeMinOfferSize(Decimal& value) const
1656  {
1657  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1658  }
1659 
1660  /// Bid side minimum quote quantity.
1662  {
1663  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1664  }
1665 
1666  ///
1667  bool symbol(StringRef& value) const
1668  {
1669  return get(Tags::Symbol).toStringRef(value);
1670  }
1671 
1672  ///
1674  {
1675  return getIntEnumFieldValue<ListMethod>(*this, Tags::ListMethod);
1676  }
1677 
1678  ///
1680  {
1681  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1682  }
1683 
1684  ///
1686  {
1687  return SecurityClassifications(getOptionalGroup(Tags::NoSecurityClassifications));
1688  }
1689 
1690  private:
1691  friend class InstrumentSnapshotWrapper;
1693 
1694  InstrumentSnapshot (const void* impl)
1695  : Message (impl)
1696  {
1697  }
1698  };
1699  }
1700  }
1701 }
InstrumentAttributes instrumentAttributes() const
Instrument attributes.
bool minTradeVol(Decimal &value) const
The minimum tradable unit of a bond.
const Tag NoInstrumentParties
Definition: Tags.h:210
bool minPriceIncrementClearing(Decimal &price) const
Defines the minimum increment for trade prices in clearing notation (clearing tick size)...
MarketSegmentId marketSegmentId() const
Product identifier.
const Tag MinPriceIncrement
Definition: Tags.h:89
PostTradeAnonymityType::Enum postTradeAnonymity() const
Only for cash.
bool legRatioMultiplier(UInt32 &value) const
Common integer multiple of the option legs for Option Volatility Strategies.
const Tag NoSecurityClassifications
Definition: Tags.h:363
const Tag UnderlyingSecurityID
Definition: Tags.h:157
AccruedInterestCalculationMethod::Enum couponDayCount() const
Defines the Accrued interest Calculation Method.
bool instrumentPricePrecision(UInt32 &value) const
Instrument Price Precision.
bool quotingStartTime(StringRef &value) const
QuotingStartTime.
const Tag NoTradingSessionRules
Definition: Tags.h:232
bool minPriceIncrement(Decimal &increment) const
Defines the minimum price movement in ticks (tick size).
const Tag LowExercisePriceOptionIndicator
Definition: Tags.h:150
InstrumentType::Enum productComplex() const
Type of Market Data update action.
bool displayDay(UInt32 &value) const
Display Day.
ContractFrequency::Enum contractFrequency() const
Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
bool contractMultiplier(Decimal &multiplier) const
Contract Multiplier.
InstrumentPartyRole::Enum role() const
bool contractDate(UInt32 &value) const
Actual contract start date.
const Tag ContractDisplayInstruction
Definition: Tags.h:284
bool quoteSizeRuleMinBidSize(Decimal &value) const
Bid side minimum quote quantity.
const Tag VolatilityCorridorIntradayAuction
Definition: Tags.h:308
ValuationMethod::Enum valuationMethod() const
Traditional or futures margin style.
const Tag SecurityClassificationValue
Definition: Tags.h:362
bool volatilityCorridorContinuous(UInt32 &value) const
Reference to Volatility Corridor Table in Continuous.
SecurityClassifications securityClassifications() const
StringRef id() const
Identifies a party associated with an instrument.
MultilegModel::Enum multilegModel() const
Multileg model.
bool couponPaymentDate(UInt32 &value) const
Upcoming Coupon payment date.
const Tag MidpointExecVenueID
Definition: Tags.h:360
InstrumentPartyIDSource::Enum idSource() const
const Tag VolatilityCorridorOpeningAuction
Definition: Tags.h:307
DisplayDayOfWeek::Enum displayDayOfWeek() const
The day of week of the weekly contract.
SecurityClassificationReasonType::Enum securityClassificationReason() const
bool previousCouponPaymentDate(UInt32 &value) const
Previous coupon payment date.
const Tag QuantityScalingFactor
Definition: Tags.h:343
const Tag TradingSessionSubID
Definition: Tags.h:77
ContractDisplayInstruction::Enum contractDisplayInstruction() const
Defines the instrument display instruction.
const Tag PostTradeAnonymity
Definition: Tags.h:222
bool couponRate(Decimal &value) const
Instrument identifier of the leg security.
DepositType::Enum depositType() const
DepositType.
const Tag InstrumentPartyRoleQualifier
Definition: Tags.h:216
bool settlCurrency(StringRef &desc) const
Settlement currency.
const Tag InstrumentPartyRole
Definition: Tags.h:215
bool transactTime(UInt64 &time) const
Transact Time.
bool securityDesc(StringRef &desc) const
Security description.
InstrumentAuctionType::Enum instrumentAuctionType() const
InstrumentAuctionType.
PriceType::Enum priceType() const
The unit in which an instrument is quoted/stated when buying or selling. Only for cash...
const Tag InstrumentPartyIDSource
Definition: Tags.h:214
Defines all the months in the year.
Definition: Timestamp.h:35
const Tag VolatilityCorridorContinuous
Definition: Tags.h:310
bool displayQuarter(UInt32 &value) const
The Display Quarter denotes the three-month period inside a year.
SecurityId securityId() const
Instrument identifier.
bool optAttribute(UInt32 &attribute) const
Version of an option. Version can change as a result of corporate actions or events.
const Tag MaturityFrequencyUnit
Definition: Tags.h:355
const Tag MinPriceIncrementAmount
Definition: Tags.h:97
DisplaySeason::Enum displaySeason() const
Defines the instrument display instruction.
unsigned int UInt32
Definition: Numeric.h:41
Definition: Defines.h:30
Decimal type for better precision.
Definition: Numeric.h:63
const Tag SecurityClassificationReason
Definition: Tags.h:361
const Tag LegRatioMultiplier
Definition: Tags.h:287
const Tag InstrumentPricePrecision
Definition: Tags.h:149
bool minPriceIncrementAmount(Decimal &value) const
Defines the minimum price movement in the respective currency (tick value).
TradingSessionSubID::Enum tradingSessionSubID() const
Defines the trading session sub ID.
bool volatilityCorridorIntradayAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Intraday Auction.
Indicates timestamp in "YYYYMMDD" format.
Definition: Timestamp.h:70
Int64 SecurityId
Alias for Security Id type.
Definition: Defines.h:51
bool riskSensitivityFactor(Decimal &value) const
Risk Sensitivity Factor.
const Tag ContractGenerationNumber
Definition: Tags.h:121
bool currency(StringRef &value) const
Currency as published in ISO 4217.
InstrumentSnapshotLegs legs() const
Legs.
bool securitySubType(UInt32 &type) const
Standard strategy type for complex instruments.
bool contractGenerationNumber(UInt32 &number) const
Contract generation.
UInt32 tradingSessionID() const
Trading Session ID.
const Tag UnderlyingMarketSegmentID
Definition: Tags.h:289
bool issueDate(UInt32 &date) const
Issue date of instrument.
const Tag StrikePricePrecision
Definition: Tags.h:148
ExerciseStyle::Enum exerciseStyle() const
Exercise Style.
bool quoteSizeMinOfferSize(Decimal &value) const
Bid side minimum quote quantity.
bool displayRelativeDay(Int32 &value) const
Display Relative Day.
const Tag DisplayRelativeDay
Definition: Tags.h:299
SecurityClassificationValueType::Enum securityClassificationValue() const
ImpliedMarketIndicator::Enum impliedMarketIndicator() const
Implied market indicator.
bool securityExchange(StringRef &exchange) const
MIC (ISO 10383), used to identify an instrument of a co-operation partner.
bool underlyingMarketSegmentID(UInt32 &val) const
Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
bool underlyingSecurityID(Int64 &val) const
Refers to SecurityID (48) from the underlying Instrument Snapshot.
FlatIndicator::Enum flatIndicator() const
The Flat Indicator of a bond.
Represents timestamp without time-zone information.
Definition: Timestamp.h:87
bool maturityMonthYear(UInt32 &monthYear) const
Expiration month (YYYYMM).
bool contractDateType(StringRef &value) const
A symbol to describe the type of ContractDate.
CoverIndicator::Enum coverIndicator() const
CoverIndicator.
bool displayMonth(UInt32 &value) const
Display Month.
bool cfiCode(StringRef &desc) const
Indicates the type of security using ISO 10962 standard.
bool isPrimary() const
Defines, if this contract based on its contract generation cycle, is considered primary.
ContractCycleSubType::Enum contractCycleSubType() const
Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
ContractIdentificationEligibility::Enum contractIdentificationEligibility() const
Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely wi...
SecurityType::Enum securityType() const
Type of security.
ContractCycleType::Enum contractCycleType() const
Defines the instrument cycle type.
bool strikePricePrecision(UInt32 &precision) const
Strike Price Precision.
const Tag SecurityAltIDSource
Definition: Tags.h:68
bool displayName(StringRef &desc) const
Display Name.
bool settlBusinessDays(UInt32 &value) const
Settlement Business Days.
bool lowExercisePriceOptionIndicator() const
Lepo Flag.
bool assetSubType(UInt32 &val) const
AssetSubType.
StringRef securityAltID() const
Alternate instrument identifier.
bool priorSettlPrice(Decimal &price) const
Previous day&#39;s settlement price. Converted in trading notation in case of variance futures...
CouponType::Enum couponType() const
Coupon Type.
WarrantType::Enum warrantType() const
WarrantType.
InstrumentParties instrumentParties() const
Instrument parties.
StringRef countryOfIssue() const
The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th ...
const Tag ContractMultiplier
Definition: Tags.h:51
Exposes list of Instrument scope operators.
SecurityStatus::Enum securityStatus() const
Security Status.
ContractMonthType::Enum contractMonthType() const
Defines the instrument cycle type.
const Tag ContractCycleSubType
Definition: Tags.h:295
bool volatilityCorridorClosingAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Closing Auction.
bool volatilityCorridorOpeningAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Opening Auction.
PutOrCall::Enum putOrCall() const
Put Or Call.
InstrumentPartyRoleQualifier::Enum roleQualifier() const
InstrumentAttributeType::Enum type() const
const Tag ImpliedMarketIndicator
Definition: Tags.h:96
bool securityReferenceDataSupplement(UInt32 &value) const
UInt32 eventDate() const
Event Date.
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
const Tag ContractIdentificationEligibility
Definition: Tags.h:293
bool origStrikePrice(Decimal &price) const
Original strike price prior to corporate action, e.g. 5.20.
bool displayYear(UInt32 &value) const
Display Year.
Alternate identifier entry.
const Tag PreviousCouponPaymentDate
Definition: Tags.h:247
bool priceDelta(Decimal &value) const
Previous day&#39;s option delta provided for option instruments only.
bool strikePrice(Decimal &price) const
Strike Price.
const Tag RiskSensitivityFactor
Definition: Tags.h:371
const Tag InstrumentAuctionType
Definition: Tags.h:267
StringRef underlyingSymbol() const
Underlying symbol.
const Tag MinPriceIncrementClearing
Definition: Tags.h:220
bool refTickTableID(UInt32 &time) const
Reference to tick size table identifier from product level message.
const Tag MaturityMonthYear
Definition: Tags.h:46
bool unitOfMeasure(StringRef &val) const
UnitOfMeasure.
StringRef securityAltIDSource() const
Security alternate id source.
const Tag VolatilityCorridorClosingAuction
Definition: Tags.h:309
const Tag FinalSettlementReferenceDate
Definition: Tags.h:285
bool contractMonthYear(UInt32 &value) const
Contract start month.
EventType::Enum eventType() const
Event Type.
UInt32 priceRangeRuleID() const
Bid side minimum quote quantity.
static Timestamp parse(const std::string &, TimestampFormat::Enum=TimestampFormat::YYYYMMDDHHMMSSNsec)
const Tag SecurityReferenceDataSupplement
Definition: Tags.h:354
bool quotingEndTime(StringRef &value) const
QuotingEndTime.
bool assetType(UInt32 &val) const
AssetType.
LastFragment::Enum lastFragment() const
Indicates whether this message is the last in a sequence of messages that together convey a joint lis...
MidpointTrading::Enum midpointTrading() const
MidpointTrading.
MaturityFrequencyUnit::Enum maturityFrequencyUnit() const
bool displayWeek(UInt32 &value) const
Display Week.
const Tag SecurityExchange
Definition: Tags.h:50
bool maturityDate(Timestamp &date) const
Actual expiration day of the instrument (YYYYMMDD).
Exposes list of available security types.