OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  16.1.3
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 PriceType
652  {
653  enum Enum
654  {
655  /// Used to identify absence of value.
656  Undefined = -1,
657 
658  ///
659  Percent = 0,
660  ///
661  Shares = 1,
662  ///
663  Points = 2,
664  };
665  };
666 
667  struct ONIXS_EUREX_EMDI_API ContractIdentificationEligibility
668  {
669  enum Enum
670  {
671  /// Used to identify absence of value.
672  Undefined = -1,
673 
674  ///
676 
677  ///
679 
680  ///
682  };
683  };
684 
685  ///
686  struct ONIXS_EUREX_EMDI_API ContractMonthType
687  {
688  enum Enum
689  {
690  /// Used to identify absence of value.
691  Undefined = -1,
692 
693  ///
694  MaturityMonth = 1,
695 
696  ///
698 
699  ///
701 
702  ///
704 
705  ///
707  };
708  };
709 
710 
711  struct ONIXS_EUREX_EMDI_API ContractCycleType
712  {
713  enum Enum
714  {
715  /// Used to identify absence of value.
716  Undefined = -1,
717 
718  ///
719  Dayly = 0,
720 
721  ///
723 
724  ///
726 
727  ///
729 
730  ///
732 
733  ///
735  };
736  };
737 
738  struct ONIXS_EUREX_EMDI_API ContractCycleSubType
739  {
740  enum Enum
741  {
742  /// Used to identify absence of value.
743  Undefined = -1,
744 
745  ///
746  EndOfMonth = 0,
747  };
748  };
749 
750  struct ONIXS_EUREX_EMDI_API ContractFrequency
751  {
752  enum Enum
753  {
754  /// Used to identify absence of value.
755  Undefined = -1,
756 
757  ///
758  Day = 0,
759 
760  ///
762 
763  ///
765 
766  ///
768 
769  ///
770  EndOfMonth
771 
772  };
773  };
774 
775  struct ONIXS_EUREX_EMDI_API ContractDisplayInstruction
776  {
777  enum Enum
778  {
779  /// Used to identify absence of value.
780  Undefined = -1,
781 
782  ///
783  None = 0,
784 
785  ///
787 
788  ///
790 
791  ///
793 
794  ///
796 
797  ///
799 
800  ///
802 
803  ///
805 
806  ///
808 
809  ///
811 
812  ///
814 
815  ///
816  EndOfMonth
817  };
818  };
819 
820  struct ONIXS_EUREX_EMDI_API DisplaySeason
821  {
822  enum Enum
823  {
824  /// Used to identify absence of value.
825  Undefined = -1,
826 
827  ///
828  Summer = 0,
829 
830  ///
832  };
833  };
834 
835  class InstrumentParties : public TypedGroup<InstrumentParty>
836  {
837  private:
838  explicit
839  InstrumentParties (const Group& group)
841  {
842  }
843 
844  friend class InstrumentSnapshot;
845  };
846 
847  /// Instrument Attribute.
848  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
849  {
850  public:
851 
852  ///
854  {
855  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
856  }
857 
858  ///
859  StringRef value() const
860  {
861  StringRef val;
862  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
863  }
864 
865  private:
867 
868  InstrumentAttribute (const GroupInstance& groupInstance)
869  : GroupInstance (groupInstance)
870  {
871  }
872  };
873 
874  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
875  {
876  private:
877  explicit
878  InstrumentAttributes (const Group& group)
880  {
881  }
882 
883  friend class InstrumentSnapshot;
884  };
885 
886 
887  /// Event.
888  class ONIXS_EUREX_EMDI_API Event : GroupInstance
889  {
890  public:
891  /// Event Type
893  {
894  return getIntEnumFieldValue<EventType>(*this, Tags::EventType);
895  }
896 
897  /// Event Date
899  {
900  return getUInt32 (Tags::EventDate);
901  }
902 
903  private:
904  friend class TypedGroup<Event>;
905 
906  Event (const GroupInstance& groupInstance)
907  : GroupInstance (groupInstance)
908  {
909  }
910  };
911 
912  class Events : public TypedGroup<Event>
913  {
914  private:
915  explicit
916  Events (const Group& group)
917  : TypedGroup<Event> (group)
918  {
919  }
920 
921  friend class InstrumentSnapshot;
922  };
923 
924  ///
925  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
926  {
927  private:
928  explicit
929  InstrumentSnapshotLegs (const Group& group)
930  : TypedGroup<InstrumentLeg> (group)
931  {
932  }
933 
934  friend class InstrumentSnapshot;
935  };
936 
937 
938  /// TradingSessionRules
939  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
940  {
941  public:
942 
943  /// Trading Session ID
945  {
946  return 0u;
947  }
948 
949  /// Defines the trading session sub ID.
951  {
952  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
953  }
954 
955  private:
957 
958  TradingSessionRule (const GroupInstance& groupInstance)
959  : GroupInstance (groupInstance)
960  {
961  }
962  };
963 
964  ///
965  class TradingSessionRules : public TypedGroup<TradingSessionRule>
966  {
967  private:
968  explicit
969  TradingSessionRules (const Group& group)
971  {
972  }
973 
974  friend class InstrumentSnapshot;
975  };
976 
977  /// Instrument snapshot.
978  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
979  {
980  public:
981  /// Instrument identifier.
983  {
984  return getInt64 (Tags::SecurityID);
985  }
986 
987  /// Entries.
989  {
990  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
991  }
992 
993  /// Type of security.
995  {
996  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
997  }
998 
999  /// Security Status.
1001  {
1002  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
1003  }
1004 
1005  /// Security description
1006  bool securityDesc(StringRef& desc) const
1007  {
1008  return get (Tags::SecurityDesc).toStringRef (desc);
1009  }
1010 
1011  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
1012  bool securityExchange (StringRef& exchange) const
1013  {
1014  return get (Tags::SecurityExchange).toStringRef (exchange);
1015  }
1016 
1017  /// Type of Market Data update action
1019  {
1020  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
1021  }
1022 
1023  /// Indicates the type of security using ISO 10962 standard.
1024  bool cfiCode(StringRef& desc) const
1025  {
1026  return get (Tags::CFICode).toStringRef (desc);
1027  }
1028 
1029  /// Display Name
1030  bool displayName(StringRef& desc) const
1031  {
1032  return get(Tags::DisplayName).toStringRef(desc);
1033  }
1034 
1035  /// Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely within a product.
1037  {
1038  return getIntEnumFieldValue<ContractIdentificationEligibility>(*this, Tags::ContractIdentificationEligibility);
1039  }
1040 
1041  /// Defines, if this contract based on its contract generation cycle, is considered primary.
1042  bool isPrimary() const
1043  {
1044  UInt32 value;
1045  return get(Tags::IsPrimary).toNumber(value) ? (value == 1) : false;
1046  }
1047 
1048  ///
1049  bool quantityScalingFactor(UInt32& value) const
1050  {
1051  return get(Tags::QuantityScalingFactor).toNumber(value);
1052  }
1053 
1054  ///
1056  {
1057  return get (Tags::SecurityReferenceDataSupplement).toNumber (value);
1058  }
1059 
1060  /// Actual contract start date
1061  bool contractDate (UInt32& value)
1062  {
1063  return get (Tags::ContractDate).toNumber (value);
1064  }
1065 
1066  /// A symbol to describe the type of ContractDate
1068  {
1069  return get(Tags::ContractDateType).toStringRef(value);
1070  }
1071 
1072  /// Contract start month
1074  {
1075  return get (Tags::ContractMonthYear).toNumber (value);
1076  }
1077 
1078  /// Defines the instrument cycle type
1080  {
1081  return getIntEnumFieldValue<ContractMonthType>(*this, Tags::ContractMonthType);
1082  }
1083 
1084  /// Defines the instrument cycle type
1086  {
1087  return getIntEnumFieldValue<ContractCycleType>(*this, Tags::ContractCycleType);
1088  }
1089 
1090  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1092  {
1093  return getIntEnumFieldValue<ContractCycleSubType>(*this, Tags::ContractCycleSubType);
1094  }
1095 
1096  ///
1098  {
1099  return getIntEnumFieldValue<MaturityFrequencyUnit>(*this, Tags::MaturityFrequencyUnit);
1100  }
1101 
1102  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1104  {
1105  return getIntEnumFieldValue<ContractFrequency>(*this, Tags::ContractFrequency);
1106  }
1107 
1108  /// Defines the instrument display instruction
1110  {
1111  return getIntEnumFieldValue<ContractDisplayInstruction>(*this, Tags::ContractDisplayInstruction);
1112  }
1113 
1114  /// Display Day
1115  bool displayDay(UInt32& value)
1116  {
1117  return get(Tags::DisplayDay).toNumber(value);
1118  }
1119 
1120  /// Display Relative Day
1122  {
1123  return get(Tags::DisplayRelativeDay).toNumber(value);
1124  }
1125 
1126  /// Display Week
1127  bool displayWeek(UInt32& value)
1128  {
1129  return get(Tags::DisplayWeek).toNumber(value);
1130  }
1131 
1132  /// The day of week of the weekly contract.
1134  {
1135  return getIntEnumFieldValue<DisplayDayOfWeek>(*this, Tags::DisplayDayOfWeek);
1136  }
1137 
1138  /// Display Month
1139  bool displayMonth(UInt32& value)
1140  {
1141  return get(Tags::DisplayMonth).toNumber(value);
1142  }
1143 
1144  /// The Display Quarter denotes the three-month period inside a year.
1145  bool displayQuarter(UInt32& value)
1146  {
1147  return get(Tags::DisplayQuarter).toNumber(value);
1148  }
1149 
1150  /// Defines the instrument display instruction
1152  {
1153  return getIntEnumFieldValue<DisplaySeason>(*this, Tags::DisplaySeason);
1154  }
1155 
1156  /// Display Year
1157  bool displayYear(UInt32& value)
1158  {
1159  return get(Tags::DisplayYear).toNumber(value);
1160  }
1161 
1162  /// Strike Price
1163  bool strikePrice (Decimal& price) const
1164  {
1165  return get (Tags::StrikePrice).toNumber (price);
1166  }
1167 
1168  /// Strike Price Precision
1169  bool strikePricePrecision (UInt32& precision) const
1170  {
1171  return get (Tags::StrikePricePrecision).toNumber (precision);
1172  }
1173 
1174  /// Contract Multiplier
1175  bool contractMultiplier (Decimal& multiplier) const
1176  {
1177  return get (Tags::ContractMultiplier).toNumber (multiplier);
1178  }
1179 
1180  /// Put Or Call
1182  {
1183  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
1184  }
1185 
1186  /// Version of an option. Version can change as a result of corporate actions or events.
1187  bool optAttribute (UInt32& attribute) const
1188  {
1189  return get (Tags::OptAttribute).toNumber (attribute);
1190  }
1191 
1192  /// Exercise Style
1194  {
1195  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
1196  }
1197 
1198  /// Original strike price prior to corporate action, e.g. 5.20.
1199  bool origStrikePrice (Decimal& price) const
1200  {
1201  return get (Tags::OrigStrikePrice).toNumber (price);
1202  }
1203 
1204  /// Contract generation.
1205  bool contractGenerationNumber (UInt32& number) const
1206  {
1207  return get (Tags::ContractGenerationNumber).toNumber (number);
1208  }
1209 
1210  /// Lepo Flag
1212  {
1213  UInt32 value;
1214  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
1215  }
1216 
1217  /// Traditional or futures margin style.
1219  {
1220  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
1221  }
1222 
1223  ///
1225  {
1226  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
1227  }
1228 
1229  ///
1231  {
1232  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
1233  }
1234 
1235  /// Previous day's settlement price. Converted in trading notation in case of variance futures.
1236  bool priorSettlPrice (Decimal& price) const
1237  {
1238  return get (Tags::PriorSettlPrice).toNumber (price);
1239  }
1240 
1241  /// Previous day�s option delta provided for option instruments only.
1242  bool priceDelta(Decimal& value) const
1243  {
1244  return get(Tags::PriceDelta).toNumber(value);
1245  }
1246 
1247  /// Indicates whether this message is the last in a sequence of messages that together convey a joint list of InstrmtLegGrp.
1249  {
1250  return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
1251  }
1252 
1253  /// Common integer multiple of the option legs for Option Volatility Strategies.
1254  bool legRatioMultiplier(UInt32& value) const
1255  {
1256  return get(Tags::LegRatioMultiplier).toNumber(value);
1257  }
1258 
1259  /// Legs
1261  {
1262  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
1263  }
1264 
1265  /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
1267  {
1268  return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
1269  }
1270 
1271  /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
1272  bool underlyingSecurityID(Int64& val) const
1273  {
1274  return get(Tags::UnderlyingSecurityID).toNumber(val);
1275  }
1276 
1277 
1278  /// UnitOfMeasure
1279  bool unitOfMeasure(StringRef& val) const
1280  {
1281  return get(Tags::UnitOfMeasure).toStringRef(val);
1282  }
1283 
1284  /// AssetType
1285  bool assetType(UInt32& val) const
1286  {
1287  return get(Tags::AssetType).toNumber(val);
1288  }
1289 
1290  /// AssetSubType
1291  bool assetSubType(UInt32& val) const
1292  {
1293  return get(Tags::AssetSubType).toNumber(val);
1294  }
1295 
1296  /// Transact Time
1297  bool transactTime (UInt64& time) const
1298  {
1299  return get (Tags::TransactTime).toNumber (time);
1300  }
1301 
1302  /// Reference to tick size table identifier from product level message.
1303  bool refTickTableID (UInt32& time) const
1304  {
1305  return get (Tags::RefTickTableID).toNumber (time);
1306  }
1307 
1308  /// Currency as published in ISO 4217.
1309  bool currency (StringRef& value) const
1310  {
1311  return get (Tags::Currency).toStringRef (value);
1312  }
1313 
1314  /// Settlement currency.
1315  bool settlCurrency(StringRef& desc) const
1316  {
1317  return get (Tags::SettlCurrency).toStringRef (desc);
1318  }
1319 
1320  /// DepositType
1322  {
1323  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
1324  }
1325 
1326  /// Issue date of instrument.
1327  bool issueDate(UInt32& date) const
1328  {
1329  return get(Tags::IssueDate).toNumber(date);
1330  }
1331 
1332  ///
1333  bool roundLot(Decimal& value) const
1334  {
1335  return get(Tags::RoundLot).toNumber(value);
1336  }
1337 
1338  /// The minimum tradable unit of a bond.
1339  bool minTradeVol(Decimal& value) const
1340  {
1341  return get(Tags::MinTradeVol).toNumber(value);
1342  }
1343 
1344  ///
1345  bool maxTradeVol(Decimal& value) const
1346  {
1347  return get(Tags::MaxTradeVol).toNumber(value);
1348  }
1349 
1350  ///
1351  bool maxTradeVal(Decimal& value) const
1352  {
1353  return get(Tags::MaxTradeVal).toNumber(value);
1354  }
1355 
1356  /// QuotingStartTime
1357  bool quotingStartTime(StringRef& value) const
1358  {
1359  return get(Tags::QuotingStartTime).toStringRef(value);
1360  }
1361 
1362  /// QuotingEndTime
1363  bool quotingEndTime(StringRef& value) const
1364  {
1365  return get(Tags::QuotingEndTime).toStringRef(value);
1366  }
1367 
1368  /// InstrumentAuctionType
1370  {
1371  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
1372  }
1373 
1374  /// Instrument parties.
1376  {
1377  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
1378  }
1379 
1380  /// Underlying symbol.
1382  {
1383  return getStringRef(Tags::UnderlyingSymbol);
1384  }
1385 
1386  /// Instrument identifier of the leg security.
1387  bool couponRate(Decimal& value) const
1388  {
1389  return get(Tags::CouponRate).toNumber(value);
1390  }
1391 
1392  /// Previous coupon payment date.
1394  {
1395  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
1396  }
1397 
1398  /// Upcoming Coupon payment date.
1399  bool couponPaymentDate(UInt32& value) const
1400  {
1401  return get(Tags::CouponPaymentDate).toNumber(value);
1402  }
1403 
1404  /// Defines the Accrued interest Calculation Method.
1406  {
1407  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
1408  }
1409 
1410  /// Coupon Type
1412  {
1413  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
1414  }
1415 
1416  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
1418  {
1419  return getStringRef(Tags::CountryOfIssue);
1420  }
1421 
1422  /// The Flat Indicator of a bond.
1424  {
1425  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
1426  }
1427 
1428  /// WarrantType
1430  {
1431  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
1432  }
1433 
1434  /// CoverIndicator
1436  {
1437  return getIntEnumFieldValue<CoverIndicator>(*this, Tags::CoverIndicator);
1438  }
1439 
1440  /// Reference to Volatility Corridor Table for Opening Auction
1442  {
1443  return get(Tags::VolatilityCorridorOpeningAuction).toNumber(value);
1444  }
1445 
1446  /// Reference to Volatility Corridor Table for Intraday Auction
1448  {
1449  return get(Tags::VolatilityCorridorIntradayAuction).toNumber(value);
1450  }
1451 
1452  /// Reference to Volatility Corridor Table for Closing Auction
1454  {
1455  return get(Tags::VolatilityCorridorClosingAuction).toNumber(value);
1456  }
1457 
1458  /// Reference to Volatility Corridor Table in Continuous
1460  {
1461  return get(Tags::VolatilityCorridorContinuous).toNumber(value);
1462  }
1463 
1464  /// Instrument attributes
1466  {
1467  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1468  }
1469 
1470  /// Events.
1471  Events events() const
1472  {
1473  return Events ( getGroup (Tags::NoEvents) );
1474  }
1475 
1476  /// Instrument Price Precision
1477  bool instrumentPricePrecision (UInt32& value) const
1478  {
1479  return get (Tags::InstrumentPricePrecision).toNumber (value);
1480  }
1481 
1482  /// Defines the minimum price movement in ticks (tick size).
1483  bool minPriceIncrement (Decimal& increment) const
1484  {
1485  return get (Tags::MinPriceIncrement).toNumber (increment);
1486  }
1487 
1488  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1490  {
1491  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1492  }
1493 
1494  /// Defines the minimum price movement in the respective currency (tick value).
1496  {
1497  return getDecimal (Tags::MinPriceIncrementAmount);
1498  }
1499 
1500  /// Actual expiration day of the instrument (YYYYMMDD).
1501  bool maturityDate(Timestamp& date) const
1502  {
1503  UInt32 tmp;
1504  if (get(Tags::MaturityDate).toNumber(tmp))
1505  {
1507  return true;
1508  }
1509  return false;
1510  }
1511 
1512  /// Expiration month (YYYYMM).
1513  bool maturityMonthYear(UInt32& monthYear) const
1514  {
1515  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1516  }
1517 
1518  /// Standard strategy type for complex instruments.
1519  bool securitySubType(UInt32& type) const
1520  {
1521  return get(Tags::SecuritySubType).toNumber(type);
1522  }
1523 
1524  ///
1525  UInt64 relatedSecurityId() const
1526  {
1527  return getUInt64 (Tags::RelatedSecurityID);
1528  }
1529 
1530  ///
1532  {
1533  return StringRef("M");
1534  }
1535 
1536  /// Product identifier.
1538  {
1539  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1540  }
1541 
1542  /// Implied market indicator
1544  {
1545  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1546  }
1547 
1548  /// Multileg model
1550  {
1551  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1552  }
1553 
1554  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1556  {
1557  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1558  }
1559 
1560  /// Only for cash.
1562  {
1563  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1564  }
1565 
1566  /// Settlement Business Days
1567  bool settlBusinessDays (UInt32& value) const
1568  {
1569  return get (Tags::SettlBusinessDays).toNumber (value);
1570  }
1571 
1572  /// Bid side minimum quote quantity.
1574  {
1575  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1576  }
1577 
1578  /// Bid side minimum quote quantity.
1579  bool quoteSizeMinOfferSize(Decimal& value) const
1580  {
1581  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1582  }
1583 
1584  /// Bid side minimum quote quantity.
1586  {
1587  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1588  }
1589 
1590  ///
1591  bool symbol(StringRef& value) const
1592  {
1593  return get(Tags::Symbol).toStringRef(value);
1594  }
1595 
1596  ///
1598  {
1599  return getIntEnumFieldValue<ListMethod>(*this, Tags::ListMethod);
1600  }
1601 
1602  ///
1604  {
1605  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1606  }
1607 
1608  private:
1609  friend class InstrumentSnapshotWrapper;
1611 
1612  InstrumentSnapshot (const void* impl)
1613  : Message (impl)
1614  {
1615  }
1616  };
1617  }
1618  }
1619 }
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 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.
bool volatilityCorridorContinuous(UInt32 &value) const
Reference to Volatility Corridor Table in Continuous.
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.
InstrumentPartyIDSource::Enum idSource() const
const Tag VolatilityCorridorOpeningAuction
Definition: Tags.h:307
DisplayDayOfWeek::Enum displayDayOfWeek() const
The day of week of the weekly contract.
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 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
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
SecurityAlts securityAlts() const
Entries.
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...
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.