OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  18.0.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)
1114  {
1115  return get (Tags::ContractDate).toNumber (value);
1116  }
1117 
1118  /// A symbol to describe the type of ContractDate
1120  {
1121  return get(Tags::ContractDateType).toStringRef(value);
1122  }
1123 
1124  /// Contract start month
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)
1168  {
1169  return get(Tags::DisplayDay).toNumber(value);
1170  }
1171 
1172  /// Display Relative Day
1174  {
1175  return get(Tags::DisplayRelativeDay).toNumber(value);
1176  }
1177 
1178  /// Display Week
1179  bool displayWeek(UInt32& value)
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)
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)
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)
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  /// Indicates whether this message is the last in a sequence of messages that together convey a joint list of InstrmtLegGrp.
1301  {
1302  return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
1303  }
1304 
1305  /// Common integer multiple of the option legs for Option Volatility Strategies.
1306  bool legRatioMultiplier(UInt32& value) const
1307  {
1308  return get(Tags::LegRatioMultiplier).toNumber(value);
1309  }
1310 
1311  ///
1313  {
1314  return getNonZeroIntEnumFieldValue<PriceNotation> (*this, Tags::PriceNotation);
1315  }
1316 
1317  /// Legs
1319  {
1320  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
1321  }
1322 
1323  /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
1325  {
1326  return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
1327  }
1328 
1329  /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
1330  bool underlyingSecurityID(Int64& val) const
1331  {
1332  return get(Tags::UnderlyingSecurityID).toNumber(val);
1333  }
1334 
1335 
1336  /// UnitOfMeasure
1337  bool unitOfMeasure(StringRef& val) const
1338  {
1339  return get(Tags::UnitOfMeasure).toStringRef(val);
1340  }
1341 
1342  /// AssetType
1343  bool assetType(UInt32& val) const
1344  {
1345  return get(Tags::AssetType).toNumber(val);
1346  }
1347 
1348  /// AssetSubType
1349  bool assetSubType(UInt32& val) const
1350  {
1351  return get(Tags::AssetSubType).toNumber(val);
1352  }
1353 
1354  /// Transact Time
1355  bool transactTime (UInt64& time) const
1356  {
1357  return get (Tags::TransactTime).toNumber (time);
1358  }
1359 
1360  /// Reference to tick size table identifier from product level message.
1361  bool refTickTableID (UInt32& time) const
1362  {
1363  return get (Tags::RefTickTableID).toNumber (time);
1364  }
1365 
1366  /// Currency as published in ISO 4217.
1367  bool currency (StringRef& value) const
1368  {
1369  return get (Tags::Currency).toStringRef (value);
1370  }
1371 
1372  /// Settlement currency.
1373  bool settlCurrency(StringRef& desc) const
1374  {
1375  return get (Tags::SettlCurrency).toStringRef (desc);
1376  }
1377 
1378  /// DepositType
1380  {
1381  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
1382  }
1383 
1384  /// Issue date of instrument.
1385  bool issueDate(UInt32& date) const
1386  {
1387  return get(Tags::IssueDate).toNumber(date);
1388  }
1389 
1390  ///
1391  bool roundLot(Decimal& value) const
1392  {
1393  return get(Tags::RoundLot).toNumber(value);
1394  }
1395 
1396  /// The minimum tradable unit of a bond.
1397  bool minTradeVol(Decimal& value) const
1398  {
1399  return get(Tags::MinTradeVol).toNumber(value);
1400  }
1401 
1402  ///
1403  bool maxTradeVol(Decimal& value) const
1404  {
1405  return get(Tags::MaxTradeVol).toNumber(value);
1406  }
1407 
1408  ///
1409  bool maxTradeVal(Decimal& value) const
1410  {
1411  return get(Tags::MaxTradeVal).toNumber(value);
1412  }
1413 
1414  /// QuotingStartTime
1415  bool quotingStartTime(StringRef& value) const
1416  {
1417  return get(Tags::QuotingStartTime).toStringRef(value);
1418  }
1419 
1420  /// QuotingEndTime
1421  bool quotingEndTime(StringRef& value) const
1422  {
1423  return get(Tags::QuotingEndTime).toStringRef(value);
1424  }
1425 
1426  /// InstrumentAuctionType
1428  {
1429  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
1430  }
1431 
1432  /// MidpointTrading
1434  {
1435  return getIntEnumFieldValue<MidpointTrading>(*this, Tags::MidpointTrading);
1436  }
1437 
1438  ///
1440  {
1441  StringRef val;
1442  return get (Tags::MidpointExecVenueID).toStringRef (val) ? val : StringRef();
1443  }
1444 
1445  /// Instrument parties.
1447  {
1448  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
1449  }
1450 
1451  /// Underlying symbol.
1453  {
1454  return getStringRef(Tags::UnderlyingSymbol);
1455  }
1456 
1457  /// Instrument identifier of the leg security.
1458  bool couponRate(Decimal& value) const
1459  {
1460  return get(Tags::CouponRate).toNumber(value);
1461  }
1462 
1463  /// Previous coupon payment date.
1465  {
1466  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
1467  }
1468 
1469  /// Upcoming Coupon payment date.
1470  bool couponPaymentDate(UInt32& value) const
1471  {
1472  return get(Tags::CouponPaymentDate).toNumber(value);
1473  }
1474 
1475  /// Defines the Accrued interest Calculation Method.
1477  {
1478  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
1479  }
1480 
1481  /// Coupon Type
1483  {
1484  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
1485  }
1486 
1487  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
1489  {
1490  return getStringRef(Tags::CountryOfIssue);
1491  }
1492 
1493  /// The Flat Indicator of a bond.
1495  {
1496  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
1497  }
1498 
1499  /// WarrantType
1501  {
1502  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
1503  }
1504 
1505  /// CoverIndicator
1507  {
1508  return getIntEnumFieldValue<CoverIndicator>(*this, Tags::CoverIndicator);
1509  }
1510 
1511  /// Reference to Volatility Corridor Table for Opening Auction
1513  {
1514  return get(Tags::VolatilityCorridorOpeningAuction).toNumber(value);
1515  }
1516 
1517  /// Reference to Volatility Corridor Table for Intraday Auction
1519  {
1520  return get(Tags::VolatilityCorridorIntradayAuction).toNumber(value);
1521  }
1522 
1523  /// Reference to Volatility Corridor Table for Closing Auction
1525  {
1526  return get(Tags::VolatilityCorridorClosingAuction).toNumber(value);
1527  }
1528 
1529  /// Reference to Volatility Corridor Table in Continuous
1531  {
1532  return get(Tags::VolatilityCorridorContinuous).toNumber(value);
1533  }
1534 
1535  /// Instrument attributes
1537  {
1538  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1539  }
1540 
1541  /// Events.
1542  Events events() const
1543  {
1544  return Events ( getGroup (Tags::NoEvents) );
1545  }
1546 
1547  /// Instrument Price Precision
1548  bool instrumentPricePrecision (UInt32& value) const
1549  {
1550  return get (Tags::InstrumentPricePrecision).toNumber (value);
1551  }
1552 
1553  /// Defines the minimum price movement in ticks (tick size).
1554  bool minPriceIncrement (Decimal& increment) const
1555  {
1556  return get (Tags::MinPriceIncrement).toNumber (increment);
1557  }
1558 
1559  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1561  {
1562  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1563  }
1564 
1565  /// Defines the minimum price movement in the respective currency (tick value).
1567  {
1568  return getDecimal (Tags::MinPriceIncrementAmount);
1569  }
1570 
1571  /// Actual expiration day of the instrument (YYYYMMDD).
1572  bool maturityDate(Timestamp& date) const
1573  {
1574  UInt32 tmp;
1575  if (get(Tags::MaturityDate).toNumber(tmp))
1576  {
1578  return true;
1579  }
1580  return false;
1581  }
1582 
1583  /// Expiration month (YYYYMM).
1584  bool maturityMonthYear(UInt32& monthYear) const
1585  {
1586  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1587  }
1588 
1589  /// Standard strategy type for complex instruments.
1590  bool securitySubType(UInt32& type) const
1591  {
1592  return get(Tags::SecuritySubType).toNumber(type);
1593  }
1594 
1595  ///
1596  UInt64 relatedSecurityId() const
1597  {
1598  return getUInt64 (Tags::RelatedSecurityID);
1599  }
1600 
1601  ///
1603  {
1604  return StringRef("M");
1605  }
1606 
1607  /// Product identifier.
1609  {
1610  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1611  }
1612 
1613  /// Implied market indicator
1615  {
1616  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1617  }
1618 
1619  /// Multileg model
1621  {
1622  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1623  }
1624 
1625  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1627  {
1628  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1629  }
1630 
1631  /// Only for cash.
1633  {
1634  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1635  }
1636 
1637  /// Settlement Business Days
1638  bool settlBusinessDays (UInt32& value) const
1639  {
1640  return get (Tags::SettlBusinessDays).toNumber (value);
1641  }
1642 
1643  /// Bid side minimum quote quantity.
1645  {
1646  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1647  }
1648 
1649  /// Bid side minimum quote quantity.
1650  bool quoteSizeMinOfferSize(Decimal& value) const
1651  {
1652  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1653  }
1654 
1655  /// Bid side minimum quote quantity.
1657  {
1658  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1659  }
1660 
1661  ///
1662  bool symbol(StringRef& value) const
1663  {
1664  return get(Tags::Symbol).toStringRef(value);
1665  }
1666 
1667  ///
1669  {
1670  return getIntEnumFieldValue<ListMethod>(*this, Tags::ListMethod);
1671  }
1672 
1673  ///
1675  {
1676  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1677  }
1678 
1679  ///
1681  {
1682  return SecurityClassifications(getOptionalGroup(Tags::NoSecurityClassifications));
1683  }
1684 
1685  private:
1686  friend class InstrumentSnapshotWrapper;
1688 
1689  InstrumentSnapshot (const void* impl)
1690  : Message (impl)
1691  {
1692  }
1693  };
1694  }
1695  }
1696 }
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
bool contractMonthYear(UInt32 &value)
Contract start month.
InstrumentType::Enum productComplex() const
Type of Market Data update action.
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
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.
bool displayRelativeDay(UInt32 &value)
Display Relative Day.
const Tag InstrumentPartyRole
Definition: Tags.h:215
bool displayMonth(UInt32 &value)
Display Month.
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
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
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
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.
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.
bool contractDate(UInt32 &value)
Actual contract start date.
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).
CoverIndicator::Enum coverIndicator() const
CoverIndicator.
bool cfiCode(StringRef &desc) const
Indicates the type of security using ISO 10962 standard.
bool displayDay(UInt32 &value)
Display Day.
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
Decimal minPriceIncrementAmount() const
Defines the minimum price movement in the respective currency (tick value).
bool contractDateType(StringRef &value)
A symbol to describe the type of ContractDate.
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.
Alternate identifier entry.
const Tag PreviousCouponPaymentDate
Definition: Tags.h:247
bool priceDelta(Decimal &value) const
Previous day�s option delta provided for option instruments only.
bool strikePrice(Decimal &price) const
Strike Price.
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
bool displayWeek(UInt32 &value)
Display Week.
const Tag FinalSettlementReferenceDate
Definition: Tags.h:285
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 displayQuarter(UInt32 &value)
The Display Quarter denotes the three-month period inside a year.
bool displayYear(UInt32 &value)
Display Year.
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.