OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  9.0.0
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  ///
126  InvestmentFunds
127  };
128  };
129 
130  /// Exposes list of Instrument scope operators.
131  struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
132  {
133  enum Enum
134  {
135  /// Used to identify absence of value.
136  Undefined = -1,
137 
138  ///
139  Include = 0,
140  };
141  };
142 
143 
144  ///
145  struct ONIXS_EUREX_EMDI_API PutOrCall
146  {
147  enum Enum
148  {
149  /// Used to identify absence of value.
150  Undefined = -1,
151 
152  ///
153  Put = 0,
154 
155  ///
156  Call = 1
157  };
158  };
159 
160 
161  ///
162  struct ONIXS_EUREX_EMDI_API ExerciseStyle
163  {
164  enum Enum
165  {
166  /// Used to identify absence of value.
167  Undefined = -1,
168 
169  ///
170  European = 0,
171 
172  ///
173  American = 1
174  };
175  };
176 
177  struct ONIXS_EUREX_EMDI_API MultilegModel
178  {
179  enum Enum
180  {
181  /// Used to identify absence of value.
182  Undefined = -1,
183 
184  ///
185  PredefinedMultilegSecurity = 0,
186 
187  ///
188  UserDefinedMultilegSecurity = 1
189  };
190  };
191 
192  ///
193  struct ONIXS_EUREX_EMDI_API ValuationMethod
194  {
195  enum Enum
196  {
197  /// Used to identify absence of value.
198  Undefined = -1,
199 
200  ///
201  PremiumStyle = 0,
202 
203  ///
204  FuturesStyleMarkToMarket = 1
205  };
206  };
207 
208  ///
209  struct ONIXS_EUREX_EMDI_API WarrantType
210  {
211  enum Enum
212  {
213  /// Used to identify absence of value.
214  Undefined = -1,
215 
216  ///
217  Call = 0,
218  ///
220  ///
222  ///
224  ///
225  Other
226  };
227  };
228 
229 
230  struct ONIXS_EUREX_EMDI_API SettlMethod
231  {
232  enum Enum
233  {
234  /// Used to identify absence of value.
235  Undefined = -1,
236 
237  ///
238  Cash = 0,
239 
240  ///
241  Physical = 1
242  };
243  };
244 
245  struct ONIXS_EUREX_EMDI_API SettlSubMethod
246  {
247  enum Enum
248  {
249  /// Used to identify absence of value.
250  Undefined = -1,
251 
252  ///
253  Shares = 0,
254  Derivatives = 1,
255  PaymentVsPayment = 2,
256  Notional = 3,
257  Cascade = 4,
258  Other = 5
259  };
260  };
261 
262  struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
263  {
264  enum Enum
265  {
266  /// Used to identify absence of value.
267  Undefined = -1,
268 
269  ///
270  Proprietary = 0,
271  };
272  };
273 
274  struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
275  {
276  enum Enum
277  {
278  /// Used to identify absence of value.
279  Undefined = -1,
280 
281  ///
282  ClearingOrganization = 0,
283  ///
284  MarketMaker = 1,
285  };
286  };
287 
288  struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
289  {
290  enum Enum
291  {
292  /// Used to identify absence of value.
293  Undefined = -1,
294 
295  ///
296  DesignatedSponsor = 0,
297 
298  ///
299  Specialist
300  };
301  };
302 
303  /// Deposit Type
304  struct ONIXS_EUREX_EMDI_API DepositType
305  {
306  enum Enum
307  {
308  /// Used to identify absence of value.
309  Undefined = -1,
310 
311  ///
312  Auslandskassenverein = 0,
313 
314  ///
315  Girosammelverwahrung = 1,
316 
317  ///
318  Streifbandverwahrung = 2,
319 
320  ///
321  Wertpapierrechnung = 3,
322 
323  ///
324  NcsCviaT2S = 4
325  };
326  };
327 
328  /// Accrued interest Calculation Methods
329  struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
330  {
331  enum Enum
332  {
333  /// Used to identify absence of value.
334  Undefined = -1,
335 
336  ///
337  Basis30360 = 0,
338 
339  ///
341 
342  ///
344 
345  ///
347 
348  ///
350 
351  ///
353 
354  ///
356 
357  ///
359  };
360  };
361 
362  /// Coupon Types
363  struct ONIXS_EUREX_EMDI_API CouponType
364  {
365  enum Enum
366  {
367  /// Used to identify absence of value.
368  Undefined = -1,
369 
370  ///
371  Zero = 0,
372 
373  ///
375 
376  ///
378 
379  ///
381  };
382  };
383 
384  /// Flat Indicators
385  struct ONIXS_EUREX_EMDI_API FlatIndicator
386  {
387  enum Enum
388  {
389  /// Used to identify absence of value.
390  Undefined = -1,
391 
392  ///
393  NoFlat = 0,
394 
395  ///
397 
398  ///
400  };
401  };
402 
403  /// Instrument Party.
404  class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
405  {
406  public:
407 
408  /// Identifies a party associated with an instrument.
409  StringRef id() const
410  {
411  StringRef val;
412  return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
413  }
414 
415  ///
417  {
418  return getIntEnumFieldValue<InstrumentPartyIDSource> (*this, Tags::InstrumentPartyIDSource);
419  }
420 
421  ///
423  {
424  return getIntEnumFieldValue<InstrumentPartyRole> (*this, Tags::InstrumentPartyRole);
425  }
426 
427  ///
429  {
430  return getIntEnumFieldValue<InstrumentPartyRoleQualifier> (*this, Tags::InstrumentPartyRoleQualifier);
431  }
432 
433  private:
435 
436  InstrumentParty (const GroupInstance& groupInstance)
437  : GroupInstance (groupInstance)
438  {
439  }
440  };
441 
442  struct ONIXS_EUREX_EMDI_API InstrumentAttributeType
443  {
444  enum Enum
445  {
446  /// Used to identify absence of value.
447  Undefined = -1,
448 
449  ///
450  MinimumReserveOrderQuantity = 0,
451  ///
452  MinimumDisplayQuantity = 1,
453  ///
454  IssuerName = 2,
455  ///
456  IssuerNumber = 3,
457  ///
458  MarketType = 4,
459  ///
460  MarketTypeSupplement = 5,
461  ///
462  ReportingMarket = 6,
463  ///
464  CumExIndicator = 7,
465  ///
466  ProductAssignmentGroup = 8,
467  ///
468  ProductAssignmentGroupDescription = 9,
469  ///
470  PreTradeLISValue = 10,
471  ///
472  VDOMinimumExecutionVolume = 11,
473  ///
474  IlliquidAsDefinedByExchange = 12,
475  ///
476  MarketMakingObligation = 13,
477  ///
478  LiquidAsDefinedByRegulator = 14,
479  ///
480  EligibleForStressedMarketConditions = 15,
481  ///
483  ///
485  ///
487  ///
489  ///
491  ///
493  ///
495  ///
497  ///
499  ///
501  ///
503  ///
505  ///
506  LiquidityClass
507  };
508  };
509 
510  struct ONIXS_EUREX_EMDI_API InstrumentAuctionType
511  {
512  enum Enum
513  {
514  /// Used to identify absence of value.
515  Undefined = -1,
516 
517  ///
518  Default = 0,
519  ///
520  SingleAuction = 1,
521  ///
522  SpecialAuction = 2
523  };
524  };
525 
526  struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
527  {
528  enum Enum
529  {
530  /// Used to identify absence of value.
531  Undefined = -1,
532 
533  ///
534  Disabled = 0,
535  ///
536  Enabled = 1,
537  ///
538  CentralCounterparty = 2,
539  };
540  };
541 
542  struct ONIXS_EUREX_EMDI_API PriceType
543  {
544  enum Enum
545  {
546  /// Used to identify absence of value.
547  Undefined = -1,
548 
549  ///
550  Percent = 0,
551  ///
552  Shares = 1,
553  ///
554  Points = 2,
555  };
556  };
557 
558  struct ONIXS_EUREX_EMDI_API ContractCycleType
559  {
560  enum Enum
561  {
562  /// Used to identify absence of value.
563  Undefined = -1,
564 
565  ///
566  Dayly = 0,
567 
568  ///
570 
571  ///
573 
574  ///
576 
577  ///
579 
580  ///
582  };
583  };
584 
585  struct ONIXS_EUREX_EMDI_API ContractDisplayInstruction
586  {
587  enum Enum
588  {
589  /// Used to identify absence of value.
590  Undefined = -1,
591 
592  ///
593  None = 0,
594 
595  ///
597 
598  ///
600 
601  ///
603 
604  ///
606 
607  ///
609 
610  ///
612 
613  ///
615 
616  ///
618  };
619  };
620 
621  class InstrumentParties : public TypedGroup<InstrumentParty>
622  {
623  private:
624  explicit
625  InstrumentParties (const Group& group)
627  {
628  }
629 
630  friend class InstrumentSnapshot;
631  };
632 
633  /// Instrument Attribute.
634  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
635  {
636  public:
637 
638  ///
640  {
641  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
642  }
643 
644  ///
645  StringRef value() const
646  {
647  StringRef val;
648  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
649  }
650 
651  private:
653 
654  InstrumentAttribute (const GroupInstance& groupInstance)
655  : GroupInstance (groupInstance)
656  {
657  }
658  };
659 
660  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
661  {
662  private:
663  explicit
664  InstrumentAttributes (const Group& group)
666  {
667  }
668 
669  friend class InstrumentSnapshot;
670  };
671 
672 
673  /// Event.
674  class ONIXS_EUREX_EMDI_API Event : GroupInstance
675  {
676  public:
677  /// Event Type
678  bool eventType (UInt32& type) const
679  {
680  return get (Tags::EventType).toNumber (type);
681  }
682 
683  /// Event Date
685  {
686  return getUInt32 (Tags::EventDate);
687  }
688 
689  private:
690  friend class TypedGroup<Event>;
691 
692  Event (const GroupInstance& groupInstance)
693  : GroupInstance (groupInstance)
694  {
695  }
696  };
697 
698  class Events : public TypedGroup<Event>
699  {
700  private:
701  explicit
702  Events (const Group& group)
703  : TypedGroup<Event> (group)
704  {
705  }
706 
707  friend class InstrumentSnapshot;
708  };
709 
710  ///
711  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
712  {
713  private:
714  explicit
715  InstrumentSnapshotLegs (const Group& group)
716  : TypedGroup<InstrumentLeg> (group)
717  {
718  }
719 
720  friend class InstrumentSnapshot;
721  };
722 
723 
724  /// TradingSessionRules
725  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
726  {
727  public:
728 
729  /// Trading Session ID
731  {
732  return 0u;
733  }
734 
735  /// Defines the trading session sub ID.
737  {
738  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
739  }
740 
741  private:
743 
744  TradingSessionRule (const GroupInstance& groupInstance)
745  : GroupInstance (groupInstance)
746  {
747  }
748  };
749 
750  ///
751  class TradingSessionRules : public TypedGroup<TradingSessionRule>
752  {
753  private:
754  explicit
755  TradingSessionRules (const Group& group)
757  {
758  }
759 
760  friend class InstrumentSnapshot;
761  };
762 
763  /// Instrument snapshot.
764  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
765  {
766  public:
767  /// Instrument identifier.
769  {
770  return getInt64 (Tags::SecurityID);
771  }
772 
773  /// Entries.
775  {
776  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
777  }
778 
779  /// Type of security.
781  {
782  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
783  }
784 
785  /// Security Status.
787  {
788  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
789  }
790 
791  /// Security description
792  bool securityDesc(StringRef& desc) const
793  {
794  return get (Tags::SecurityDesc).toStringRef (desc);
795  }
796 
797  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
798  bool securityExchange (StringRef& exchange) const
799  {
800  return get (Tags::SecurityExchange).toStringRef (exchange);
801  }
802 
803  /// Type of Market Data update action
805  {
806  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
807  }
808 
809  /// Indicates the type of security using ISO 10962 standard.
810  bool cfiCode(StringRef desc) const
811  {
812  return get (Tags::CFICode).toStringRef (desc);
813  }
814 
815  /// Actual contract start date
816  bool contractDate (UInt32& value)
817  {
818  return get (Tags::ContractDate).toNumber (value);
819  }
820 
821  /// Contract start month
822  bool contractMonthYear (UInt32& value)
823  {
824  return get (Tags::ContractMonthYear).toNumber (value);
825  }
826 
827  /// Quarter used to identify the instrument (Q).
828  bool contractQuarter(UInt32& value)
829  {
830  return get(Tags::ContractQuarter).toNumber(value);
831  }
832 
833  /// Week used to identify the instrument (WW).
834  bool contractWeek(UInt32& value)
835  {
836  return get(Tags::ContractWeek).toNumber(value);
837  }
838 
839  /// Year used to identify the instrument (YYYY).
841  {
842  return get(Tags::ContractWeekYear).toNumber(value);
843  }
844 
845  /// Defines the instrument cycle type
847  {
848  return getIntEnumFieldValue<ContractCycleType>(*this, Tags::ContractCycleType);
849  }
850 
851  /// Defines the instrument display instruction
853  {
854  return getIntEnumFieldValue<ContractDisplayInstruction>(*this, Tags::ContractDisplayInstruction);
855  }
856 
857 
858  /// Strike Price
859  bool strikePrice (Decimal& price) const
860  {
861  return get (Tags::StrikePrice).toNumber (price);
862  }
863 
864  /// Strike Price Precision
865  bool strikePricePrecision (UInt32& precision) const
866  {
867  return get (Tags::StrikePricePrecision).toNumber (precision);
868  }
869 
870  /// Contract Multiplier
871  bool contractMultiplier (Decimal& multiplier) const
872  {
873  return get (Tags::ContractMultiplier).toNumber (multiplier);
874  }
875 
876  /// Put Or Call
878  {
879  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
880  }
881 
882  /// Version of an option. Version can change as a result of corporate actions or events.
883  bool optAttribute (UInt32& attribute) const
884  {
885  return get (Tags::OptAttribute).toNumber (attribute);
886  }
887 
888  /// Exercise Style
890  {
891  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
892  }
893 
894  /// Original strike price prior to corporate action, e.g. 5.20.
895  bool origStrikePrice (Decimal& price) const
896  {
897  return get (Tags::OrigStrikePrice).toNumber (price);
898  }
899 
900  /// Contract generation.
901  bool contractGenerationNumber (UInt32& number) const
902  {
903  return get (Tags::ContractGenerationNumber).toNumber (number);
904  }
905 
906  /// Lepo Flag
908  {
909  UInt32 value;
910  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
911  }
912 
913  /// Traditional or futures margin style.
915  {
916  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
917  }
918 
919  ///
921  {
922  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
923  }
924 
925  ///
927  {
928  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
929  }
930 
931  /// Previous day's settlement price. Converted in trading notation in case of variance futures.
932  bool priorSettlPrice (Decimal& price) const
933  {
934  return get (Tags::PriorSettlPrice).toNumber (price);
935  }
936 
937  /// Common integer multiple of the option legs for Option Volatility Strategies.
938  bool legRatioMultiplier(UInt32& value) const
939  {
940  return get(Tags::LegRatioMultiplier).toNumber(value);
941  }
942 
943  /// Legs
945  {
946  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
947  }
948 
949  /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
951  {
952  return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
953  }
954 
955  /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
956  bool underlyingSecurityID(Int64& val) const
957  {
958  return get(Tags::UnderlyingSecurityID).toNumber(val);
959  }
960 
961 
962  /// UnitOfMeasure
963  bool unitOfMeasure(StringRef& val) const
964  {
965  return get(Tags::UnitOfMeasure).toStringRef(val);
966  }
967 
968  /// AssetType
969  bool assetType(UInt32& val) const
970  {
971  return get(Tags::AssetType).toNumber(val);
972  }
973 
974  /// AssetSubType
975  bool assetSubType(UInt32& val) const
976  {
977  return get(Tags::AssetSubType).toNumber(val);
978  }
979 
980  /// Transact Time
981  bool transactTime (UInt64& time) const
982  {
983  return get (Tags::TransactTime).toNumber (time);
984  }
985 
986  /// Reference to tick size table identifier from product level message.
987  bool refTickTableID (UInt32& time) const
988  {
989  return get (Tags::RefTickTableID).toNumber (time);
990  }
991 
992  /// Currency as published in ISO 4217.
994  {
995  return getStringRef (Tags::Currency);
996  }
997 
998  /// Settlement currency.
999  bool settlCurrency(StringRef& desc) const
1000  {
1001  return get (Tags::SettlCurrency).toStringRef (desc);
1002  }
1003 
1004  /// DepositType
1006  {
1007  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
1008  }
1009 
1010  /// Issuer of instrument.
1012  {
1013  return getStringRef(Tags::Issuer);
1014  }
1015 
1016  /// Issue date of instrument.
1017  bool issueDate(UInt32& date) const
1018  {
1019  return get(Tags::IssueDate).toNumber(date);
1020  }
1021 
1022  ///
1023  bool roundLot(Decimal& value) const
1024  {
1025  return get(Tags::RoundLot).toNumber(value);
1026  }
1027 
1028  /// The minimum tradable unit of a bond.
1029  bool minTradeVol(Decimal& value) const
1030  {
1031  return get(Tags::MinTradeVol).toNumber(value);
1032  }
1033 
1034  /// QuotingStartTime
1035  bool quotingStartTime(StringRef value) const
1036  {
1037  return get(Tags::QuotingStartTime).toStringRef(value);
1038  }
1039 
1040  /// QuotingEndTime
1041  bool quotingEndTime(StringRef value) const
1042  {
1043  return get(Tags::QuotingEndTime).toStringRef(value);
1044  }
1045 
1046  /// InstrumentAuctionType
1048  {
1049  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
1050  }
1051 
1052  /// Instrument parties.
1054  {
1055  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
1056  }
1057 
1058  /// Underlying symbol.
1060  {
1061  return getStringRef(Tags::UnderlyingSymbol);
1062  }
1063 
1064  /// Instrument identifier of the leg security.
1065  bool couponRate(Decimal& value) const
1066  {
1067  return get(Tags::CouponRate).toNumber(value);
1068  }
1069 
1070  /// Previous coupon payment date.
1072  {
1073  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
1074  }
1075 
1076  /// Upcoming Coupon payment date.
1077  bool couponPaymentDate(UInt32& value) const
1078  {
1079  return get(Tags::CouponPaymentDate).toNumber(value);
1080  }
1081 
1082  /// Defines the Accrued interest Calculation Method.
1084  {
1085  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
1086  }
1087 
1088  /// Coupon Type
1090  {
1091  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
1092  }
1093 
1094  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
1096  {
1097  return getStringRef(Tags::CountryOfIssue);
1098  }
1099 
1100  /// The Flat Indicator of a bond.
1102  {
1103  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
1104  }
1105 
1106  /// WarrantType
1108  {
1109  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
1110  }
1111 
1112  /// Instrument attributes
1114  {
1115  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1116  }
1117 
1118  /// Events.
1119  Events events() const
1120  {
1121  return Events ( getGroup (Tags::NoEvents) );
1122  }
1123 
1124  /// Instrument Price Precision
1125  bool instrumentPricePrecision (UInt32& value) const
1126  {
1127  return get (Tags::InstrumentPricePrecision).toNumber (value);
1128  }
1129 
1130  /// Defines the minimum price movement in ticks (tick size).
1131  bool minPriceIncrement (Decimal& increment) const
1132  {
1133  return get (Tags::MinPriceIncrement).toNumber (increment);
1134  }
1135 
1136  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1138  {
1139  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1140  }
1141 
1142  /// Defines the minimum price movement in the respective currency (tick value).
1144  {
1145  return getDecimal (Tags::MinPriceIncrementAmount);
1146  }
1147 
1148  /// Actual expiration day of the instrument (YYYYMMDD).
1149  bool maturityDate(Timestamp& date) const
1150  {
1151  UInt32 tmp;
1152  if (get(Tags::MaturityDate).toNumber(tmp))
1153  {
1155  return true;
1156  }
1157  return false;
1158  }
1159 
1160  /// Expiration month (YYYYMM).
1161  bool maturityMonthYear(UInt32& monthYear) const
1162  {
1163  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1164  }
1165 
1166  /// Standard strategy type for complex instruments.
1167  bool securitySubType(UInt32& type) const
1168  {
1169  return get(Tags::SecuritySubType).toNumber(type);
1170  }
1171 
1172  /// Product identifier.
1174  {
1175  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1176  }
1177 
1178  /// Implied market indicator
1180  {
1181  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1182  }
1183 
1184  /// Multileg model
1186  {
1187  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1188  }
1189 
1190  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1192  {
1193  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1194  }
1195 
1196  /// Only for cash.
1198  {
1199  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1200  }
1201 
1202  /// Settlment Business Days
1203  bool settlBusinessDays (UInt32& value) const
1204  {
1205  return get (Tags::SettlBusinessDays).toNumber (value);
1206  }
1207 
1208  /// Bid side minimum quote quantity.
1210  {
1211  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1212  }
1213 
1214  /// Bid side minimum quote quantity.
1215  bool quoteSizeMinOfferSize(Decimal& value) const
1216  {
1217  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1218  }
1219 
1220  /// Bid side minimum quote quantity.
1222  {
1223  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1224  }
1225 
1226  ///
1227  bool symbol(StringRef value) const
1228  {
1229  return get(Tags::Symbol).toStringRef(value);
1230  }
1231 
1232  ///
1234  {
1235  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1236  }
1237 
1238  private:
1239  friend class InstrumentSnapshotWrapper;
1241 
1242  InstrumentSnapshot (const void* impl)
1243  : Message (impl)
1244  {
1245  }
1246  };
1247  }
1248  }
1249 }
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.
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 quotingStartTime(StringRef value) const
QuotingStartTime.
bool contractMonthYear(UInt32 &value)
Contract start month.
InstrumentType::Enum productComplex() const
Type of Market Data update action.
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.
ValuationMethod::Enum valuationMethod() const
Traditional or futures margin style.
StringRef id() const
Identifies a party associated with an instrument.
bool cfiCode(StringRef desc) const
Indicates the type of security using ISO 10962 standard.
MultilegModel::Enum multilegModel() const
Multileg model.
bool couponPaymentDate(UInt32 &value) const
Upcoming Coupon payment date.
InstrumentPartyIDSource::Enum idSource() const
bool previousCouponPaymentDate(UInt32 &value) const
Previous coupon payment date.
bool contractWeek(UInt32 &value)
Week used to identify the instrument (WW).
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
StringRef issuer() const
Issuer of instrument.
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
SecurityId securityId() const
Instrument identifier.
bool eventType(UInt32 &type) const
Event Type.
bool optAttribute(UInt32 &attribute) const
Version of an option. Version can change as a result of corporate actions or events.
const Tag MinPriceIncrementAmount
Definition: Tags.h:97
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.
Indicates timestamp in "YYYYMMDD" format.
Definition: Timestamp.h:70
bool quotingEndTime(StringRef value) const
QuotingEndTime.
Int64 SecurityId
Alias for Security Id type.
Definition: Defines.h:51
StringRef currency() const
Currency as published in ISO 4217.
const Tag ContractGenerationNumber
Definition: Tags.h:121
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.
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).
SecurityType::Enum securityType() const
Type of security.
ContractCycleType::Enum contractCycleType() const
Defines the instrument cycle type.
bool strikePricePrecision(UInt32 &precision) const
Strike Price Precision.
SettlSubMethod::Enum settlSubMethod() const
const Tag SecurityAltIDSource
Definition: Tags.h:68
bool settlBusinessDays(UInt32 &value) const
Settlment Business Days.
bool lowExercisePriceOptionIndicator() const
Lepo Flag.
bool assetSubType(UInt32 &val) const
AssetSubType.
bool contractWeekYear(UInt32 &value)
Year used to identify the instrument (YYYY).
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.
bool contractQuarter(UInt32 &value)
Quarter used to identify the instrument (Q).
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.
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).
UInt32 eventDate() const
Event Date.
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
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 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.
SecurityAlts securityAlts() const
Entries.
UInt32 priceRangeRuleID() const
Bid side minimum quote quantity.
static Timestamp parse(const std::string &, TimestampFormat::Enum=TimestampFormat::YYYYMMDDHHMMSSNsec)
bool assetType(UInt32 &val) const
AssetType.
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.