OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  7.2.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  };
123 
124  /// Exposes list of Instrument scope operators.
125  struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
126  {
127  enum Enum
128  {
129  /// Used to identify absence of value.
130  Undefined = -1,
131 
132  ///
133  Include = 0,
134  };
135  };
136 
137 
138  ///
139  struct ONIXS_EUREX_EMDI_API PutOrCall
140  {
141  enum Enum
142  {
143  /// Used to identify absence of value.
144  Undefined = -1,
145 
146  ///
147  Put = 0,
148 
149  ///
150  Call = 1
151  };
152  };
153 
154 
155  ///
156  struct ONIXS_EUREX_EMDI_API ExerciseStyle
157  {
158  enum Enum
159  {
160  /// Used to identify absence of value.
161  Undefined = -1,
162 
163  ///
164  European = 0,
165 
166  ///
167  American = 1
168  };
169  };
170 
171  struct ONIXS_EUREX_EMDI_API MultilegModel
172  {
173  enum Enum
174  {
175  /// Used to identify absence of value.
176  Undefined = -1,
177 
178  ///
179  PredefinedMultilegSecurity = 0,
180 
181  ///
182  UserDefinedMultilegSecurity = 1
183  };
184  };
185 
186  ///
187  struct ONIXS_EUREX_EMDI_API ValuationMethod
188  {
189  enum Enum
190  {
191  /// Used to identify absence of value.
192  Undefined = -1,
193 
194  ///
195  PremiumStyle = 0,
196 
197  ///
198  FuturesStyleMarkToMarket = 1
199  };
200  };
201 
202  struct ONIXS_EUREX_EMDI_API SettlMethod
203  {
204  enum Enum
205  {
206  /// Used to identify absence of value.
207  Undefined = -1,
208 
209  ///
210  Cash = 0,
211 
212  ///
213  Physical = 1
214  };
215  };
216 
217  struct ONIXS_EUREX_EMDI_API SettlSubMethod
218  {
219  enum Enum
220  {
221  /// Used to identify absence of value.
222  Undefined = -1,
223 
224  ///
225  Shares = 0,
226  Derivatives = 1,
227  PaymentVsPayment = 2,
228  Notional = 3,
229  Cascade = 4,
230  Other = 5
231  };
232  };
233 
234  struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
235  {
236  enum Enum
237  {
238  /// Used to identify absence of value.
239  Undefined = -1,
240 
241  ///
242  Proprietary = 0,
243  };
244  };
245 
246  struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
247  {
248  enum Enum
249  {
250  /// Used to identify absence of value.
251  Undefined = -1,
252 
253  ///
254  ClearingOrganization = 0,
255  ///
256  MarketMaker = 1,
257  };
258  };
259 
260  struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
261  {
262  enum Enum
263  {
264  /// Used to identify absence of value.
265  Undefined = -1,
266 
267  ///
268  DesignatedSponsor = 0,
269  };
270  };
271 
272  /// Deposit Type
273  struct ONIXS_EUREX_EMDI_API DepositType
274  {
275  enum Enum
276  {
277  /// Used to identify absence of value.
278  Undefined = -1,
279 
280  ///
281  Auslandskassenverein = 0,
282 
283  ///
284  Girosammelverwahrung = 1,
285 
286  ///
287  Streifbandverwahrung = 2,
288 
289  ///
290  Wertpapierrechnung = 3,
291  };
292  };
293 
294  /// Accrued interest Calculation Methods
295  struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
296  {
297  enum Enum
298  {
299  /// Used to identify absence of value.
300  Undefined = -1,
301 
302  ///
303  Basis30360 = 0,
304 
305  ///
307 
308  ///
310 
311  ///
313 
314  ///
316 
317  ///
319 
320  ///
322 
323  ///
325  };
326  };
327 
328  /// Coupon Types
329  struct ONIXS_EUREX_EMDI_API CouponType
330  {
331  enum Enum
332  {
333  /// Used to identify absence of value.
334  Undefined = -1,
335 
336  ///
337  Zero = 0,
338 
339  ///
341 
342  ///
344 
345  ///
347  };
348  };
349 
350  /// Flat Indicators
351  struct ONIXS_EUREX_EMDI_API FlatIndicator
352  {
353  enum Enum
354  {
355  /// Used to identify absence of value.
356  Undefined = -1,
357 
358  ///
359  NoFlat = 0,
360 
361  ///
363 
364  ///
366  };
367  };
368 
369  /// Instrument Party.
370  class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
371  {
372  public:
373 
374  /// Identifies a party associated with an instrument.
375  StringRef id() const
376  {
377  StringRef val;
378  return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
379  }
380 
381  ///
383  {
384  return getIntEnumFieldValue<InstrumentPartyIDSource> (*this, Tags::InstrumentPartyIDSource);
385  }
386 
387  ///
389  {
390  return getIntEnumFieldValue<InstrumentPartyRole> (*this, Tags::InstrumentPartyRole);
391  }
392 
393  ///
395  {
396  return getIntEnumFieldValue<InstrumentPartyRoleQualifier> (*this, Tags::InstrumentPartyRoleQualifier);
397  }
398 
399  private:
401 
402  InstrumentParty (const GroupInstance& groupInstance)
403  : GroupInstance (groupInstance)
404  {
405  }
406  };
407 
408  struct ONIXS_EUREX_EMDI_API InstrumentAttributeType
409  {
410  enum Enum
411  {
412  /// Used to identify absence of value.
413  Undefined = -1,
414 
415  ///
416  MinimumReserveOrderQuantity = 0,
417  ///
418  MinimumDisplayQuantity = 1,
419  ///
420  IssuerName = 2,
421  ///
422  IssuerNumber = 3,
423  ///
424  MarketType = 4,
425  ///
426  MarketTypeSupplement = 5,
427  ///
428  ReportingMarket = 6,
429  ///
430  CumExIndicator = 7,
431  ///
432  ProductAssignmentGroup = 8,
433  ///
434  ProductAssignmentGroupDescription = 9,
435  ///
436  PreTradeLISValue = 10,
437  ///
438  VDOMinimumExecutionVolume = 11,
439  ///
440  IlliquidAsDefinedByExchange = 12,
441  ///
442  MarketMakingObligation = 13,
443  ///
444  LiquidAsDefinedByRegulator = 14,
445  ///
446  EligibleForStressedMarketConditions = 15,
447  ///
448  EligibleForSystematicInternaliser = 16,
449  ///
450  MultiCCPEligible = 17,
451  ///
453  ///
455  ///
457  ///
459  ///
461  ///
463  ///
465  ///
467  ///
468  ReportingMarketTES
469  };
470  };
471 
472  struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
473  {
474  enum Enum
475  {
476  /// Used to identify absence of value.
477  Undefined = -1,
478 
479  ///
480  Disabled = 0,
481  ///
482  Enabled = 1,
483  ///
484  CentralCounterparty = 2,
485  };
486  };
487 
488  struct ONIXS_EUREX_EMDI_API PriceType
489  {
490  enum Enum
491  {
492  /// Used to identify absence of value.
493  Undefined = -1,
494 
495  ///
496  Percent = 0,
497  ///
498  Shares = 1,
499  ///
500  Points = 2,
501  };
502  };
503 
504  class InstrumentParties : public TypedGroup<InstrumentParty>
505  {
506  private:
507  explicit
508  InstrumentParties (const Group& group)
510  {
511  }
512 
513  friend class InstrumentSnapshot;
514  };
515 
516  /// Instrument Attribute.
517  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
518  {
519  public:
520 
521  ///
523  {
524  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
525  }
526 
527  ///
528  StringRef value() const
529  {
530  StringRef val;
531  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
532  }
533 
534  private:
536 
537  InstrumentAttribute (const GroupInstance& groupInstance)
538  : GroupInstance (groupInstance)
539  {
540  }
541  };
542 
543  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
544  {
545  private:
546  explicit
547  InstrumentAttributes (const Group& group)
549  {
550  }
551 
552  friend class InstrumentSnapshot;
553  };
554 
555 
556  /// Event.
557  class ONIXS_EUREX_EMDI_API Event : GroupInstance
558  {
559  public:
560  /// Event Type
561  bool eventType (UInt32& type) const
562  {
563  return get (Tags::EventType).toNumber (type);
564  }
565 
566  /// Event Date
568  {
569  return getUInt32 (Tags::EventDate);
570  }
571 
572  private:
573  friend class TypedGroup<Event>;
574 
575  Event (const GroupInstance& groupInstance)
576  : GroupInstance (groupInstance)
577  {
578  }
579  };
580 
581  /// TesTickRule.
582  class ONIXS_EUREX_EMDI_API TesTickRule : GroupInstance
583  {
584  /// Ref Tick Table ID
585  bool refTickTableID (UInt32& type) const
586  {
587  return get (Tags::RefTickTableID).toNumber (type);
588  }
589 
590  /// Trade Type
591  RdiTrdType::Enum trdType() const
592  {
593  return getIntEnumFieldValue<RdiTrdType>(*this, Tags::TrdType);
594  }
595 
596  private:
597  friend class TypedGroup<TesTickRule>;
598 
599  TesTickRule (const GroupInstance& groupInstance)
600  : GroupInstance (groupInstance)
601  {
602  }
603  };
604 
605  class Events : public TypedGroup<Event>
606  {
607  private:
608  explicit
609  Events (const Group& group)
610  : TypedGroup<Event> (group)
611  {
612  }
613 
614  friend class InstrumentSnapshot;
615  };
616 
617  class TesTickRules : public TypedGroup<TesTickRule>
618  {
619  private:
620  explicit
621  TesTickRules (const Group& group)
622  : TypedGroup<TesTickRule> (group)
623  {
624  }
625 
626  friend class InstrumentSnapshot;
627  };
628 
629  ///
630  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
631  {
632  private:
633  explicit
634  InstrumentSnapshotLegs (const Group& group)
635  : TypedGroup<InstrumentLeg> (group)
636  {
637  }
638 
639  friend class InstrumentSnapshot;
640  };
641 
642 
643  /// TradingSessionRules
644  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
645  {
646  public:
647 
648  /// Trading Session ID
650  {
651  return 0u;
652  }
653 
654  /// Defines the trading session sub ID.
656  {
657  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
658  }
659 
660  private:
662 
663  TradingSessionRule (const GroupInstance& groupInstance)
664  : GroupInstance (groupInstance)
665  {
666  }
667  };
668 
669  ///
670  class TradingSessionRules : public TypedGroup<TradingSessionRule>
671  {
672  private:
673  explicit
674  TradingSessionRules (const Group& group)
676  {
677  }
678 
679  friend class InstrumentSnapshot;
680  };
681 
682  /// Instrument snapshot.
683  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
684  {
685  public:
686  /// Instrument identifier.
688  {
689  return getInt64 (Tags::SecurityID);
690  }
691 
692  /// Entries.
694  {
695  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
696  }
697 
698  /// Type of security.
700  {
701  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
702  }
703 
704  /// Security Status.
706  {
707  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
708  }
709 
710  /// Security description
711  bool securityDesc(StringRef& desc) const
712  {
713  return get (Tags::SecurityDesc).toStringRef (desc);
714  }
715 
716  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
717  bool securityExchange (StringRef& exchange) const
718  {
719  return get (Tags::SecurityExchange).toStringRef (exchange);
720  }
721 
722  /// Type of Market Data update action
724  {
725  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
726  }
727 
728  /// Indicates the type of security using ISO 10962 standard.
729  bool cfiCode(StringRef desc) const
730  {
731  return get (Tags::CFICode).toStringRef (desc);
732  }
733 
734  /// Strike Price
735  bool strikePrice (Decimal& price) const
736  {
737  return get (Tags::StrikePrice).toNumber (price);
738  }
739 
740  /// Strike Price Precision
741  bool strikePricePrecision (UInt32& precision) const
742  {
743  return get (Tags::StrikePricePrecision).toNumber (precision);
744  }
745 
746  /// Contract Multiplier
747  bool contractMultiplier (Decimal& multiplier) const
748  {
749  return get (Tags::ContractMultiplier).toNumber (multiplier);
750  }
751 
752  /// Put Or Call
754  {
755  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
756  }
757 
758  /// Version of an option. Version can change as a result of corporate actions or events.
759  bool optAttribute (UInt32& attribute) const
760  {
761  return get (Tags::OptAttribute).toNumber (attribute);
762  }
763 
764  /// Exercise Style
766  {
767  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
768  }
769 
770  /// Original strike price prior to corporate action, e.g. 5.20.
771  bool origStrikePrice (Decimal& price) const
772  {
773  return get (Tags::OrigStrikePrice).toNumber (price);
774  }
775 
776  /// Contract generation.
777  bool contractGenerationNumber (UInt32& number) const
778  {
779  return get (Tags::ContractGenerationNumber).toNumber (number);
780  }
781 
782  /// Lepo Flag
784  {
785  UInt32 value;
786  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
787  }
788 
789  /// Traditional or futures margin style.
791  {
792  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
793  }
794 
795  ///
797  {
798  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
799  }
800 
801  ///
803  {
804  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
805  }
806 
807  /// Previous day�s settlement price. Converted in trading notation in case of variance futures.
808  bool priorSettlPrice (Decimal& price) const
809  {
810  return get (Tags::PriorSettlPrice).toNumber (price);
811  }
812 
813  /// Legs
815  {
816  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
817  }
818 
819  /// UnitOfMeasure
820  bool unitOfMeasure(StringRef& val) const
821  {
822  return get(Tags::UnitOfMeasure).toStringRef(val);
823  }
824 
825  /// AssetType
826  bool assetType(UInt32& val) const
827  {
828  return get(Tags::AssetType).toNumber(val);
829  }
830 
831  /// AssetSubType
832  bool assetSubType(UInt32& val) const
833  {
834  return get(Tags::AssetSubType).toNumber(val);
835  }
836 
837  /// Transact Time
838  bool transactTime (UInt64& time) const
839  {
840  return get (Tags::TransactTime).toNumber (time);
841  }
842 
843  /// Reference to tick size table identifier from product level message.
844  bool refTickTableID (UInt32& time) const
845  {
846  return get (Tags::RefTickTableID).toNumber (time);
847  }
848 
849  /// Currency as published in ISO 4217.
851  {
852  return getStringRef (Tags::Currency);
853  }
854 
855  /// Settlement currency.
856  bool settlCurrency(StringRef& desc) const
857  {
858  return get (Tags::SettlCurrency).toStringRef (desc);
859  }
860 
861  /// DepositType
863  {
864  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
865  }
866 
867  /// Issuer of instrument.
869  {
870  return getStringRef(Tags::Issuer);
871  }
872 
873  /// Issue date of instrument.
874  bool issueDate(UInt32& date) const
875  {
876  return get(Tags::IssueDate).toNumber(date);
877  }
878 
879  ///
880  bool roundLot(Decimal& value) const
881  {
882  return get(Tags::RoundLot).toNumber(value);
883  }
884 
885  /// The minimum tradable unit of a bond.
886  bool minTradeVol(Decimal& value) const
887  {
888  return get(Tags::MinTradeVol).toNumber(value);
889  }
890 
891  /// Instrument parties.
893  {
894  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
895  }
896 
897  /// Underlying symbol.
899  {
900  return getStringRef(Tags::UnderlyingSymbol);
901  }
902 
903  /// Instrument identifier of the leg security.
904  bool couponRate(Decimal& value) const
905  {
906  return get(Tags::CouponRate).toNumber(value);
907  }
908 
909  /// Previous coupon payment date.
911  {
912  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
913  }
914 
915  /// Upcoming Coupon payment date.
916  bool couponPaymentDate(UInt32& value) const
917  {
918  return get(Tags::CouponPaymentDate).toNumber(value);
919  }
920 
921  /// Defines the Accrued interest Calculation Method.
923  {
924  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
925  }
926 
927  /// Coupon Type
929  {
930  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
931  }
932 
933  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
935  {
936  return getStringRef(Tags::CountryOfIssue);
937  }
938 
939  /// The Flat Indicator of a bond.
941  {
942  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
943  }
944 
945  /// Instrument attributes
947  {
948  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
949  }
950 
951  /// Events.
952  Events events() const
953  {
954  return Events ( getGroup (Tags::NoEvents) );
955  }
956 
957  /// Events.
959  {
960  return TesTickRules ( getGroup (Tags::NoTickRules) );
961  }
962 
963  /// Instrument Price Precision
964  bool instrumentPricePrecision (UInt32& value) const
965  {
966  return get (Tags::InstrumentPricePrecision).toNumber (value);
967  }
968 
969  /// Defines the minimum price movement in ticks (tick size).
970  bool minPriceIncrement (Decimal& increment) const
971  {
972  return get (Tags::MinPriceIncrement).toNumber (increment);
973  }
974 
975  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
976  bool minPriceIncrementClearing (Decimal& price) const
977  {
978  return get (Tags::MinPriceIncrementClearing).toNumber (price);
979  }
980 
981  /// Defines the minimum price movement in the respective currency (tick value).
983  {
984  return getDecimal (Tags::MinPriceIncrementAmount);
985  }
986 
987  /// Actual expiration day of the instrument (YYYYMMDD).
988  bool maturityDate(Timestamp& date) const
989  {
990  UInt32 tmp;
991  if (get(Tags::MaturityDate).toNumber(tmp))
992  {
994  return true;
995  }
996  return false;
997  }
998 
999  /// Expiration month (YYYYMM).
1000  bool maturityMonthYear(UInt32& monthYear) const
1001  {
1002  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1003  }
1004 
1005  /// Standard strategy type for complex instruments.
1006  bool securitySubType(UInt32& type) const
1007  {
1008  return get(Tags::SecuritySubType).toNumber(type);
1009  }
1010 
1011  /// Product identifier.
1013  {
1014  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1015  }
1016 
1017  /// Implied market indicator
1019  {
1020  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1021  }
1022 
1023  /// Multileg model
1025  {
1026  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1027  }
1028 
1029  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1031  {
1032  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1033  }
1034 
1035  /// Only for cash.
1037  {
1038  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1039  }
1040 
1041  /// Settlment Business Days
1042  bool settlBusinessDays (UInt32& value) const
1043  {
1044  return get (Tags::SettlBusinessDays).toNumber (value);
1045  }
1046 
1047  /// Bid side minimum quote quantity.
1049  {
1050  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1051  }
1052 
1053  /// Bid side minimum quote quantity.
1054  bool quoteSizeMinOfferSize(Decimal& value) const
1055  {
1056  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1057  }
1058 
1059  /// Bid side minimum quote quantity.
1061  {
1062  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1063  }
1064 
1065  ///
1066  bool symbol(StringRef value) const
1067  {
1068  return get(Tags::Symbol).toStringRef(value);
1069  }
1070 
1071  ///
1073  {
1074  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1075  }
1076 
1077  private:
1080 
1081  InstrumentSnapshot (const void* impl)
1082  : Message (impl)
1083  {
1084  }
1085  };
1086  }
1087  }
1088 }
static Timestamp parse(const std::string &, TimestampFormat::Enum=TimestampFormat::YYYYMMDDHHMMSSNsec)
Definition: Timestamp.cpp:179
InstrumentAttributes instrumentAttributes() const
Instrument attributes.
bool minTradeVol(Decimal &value) const
The minimum tradable unit of a bond.
const Tag NoInstrumentParties
Definition: Tags.h:228
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:92
PostTradeAnonymityType::Enum postTradeAnonymity() const
Only for cash.
AccruedInterestCalculationMethod::Enum couponDayCount() const
Defines the Accrued interest Calculation Method.
bool instrumentPricePrecision(UInt32 &value) const
Instrument Price Precision.
const Tag NoTradingSessionRules
Definition: Tags.h:250
bool minPriceIncrement(Decimal &increment) const
Defines the minimum price movement in ticks (tick size).
const Tag LowExercisePriceOptionIndicator
Definition: Tags.h:166
InstrumentType::Enum productComplex() const
Type of Market Data update action.
bool contractMultiplier(Decimal &multiplier) const
Contract Multiplier.
InstrumentPartyRole::Enum role() const
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.
const Tag TradingSessionSubID
Definition: Tags.h:80
const Tag PostTradeAnonymity
Definition: Tags.h:240
bool couponRate(Decimal &value) const
Instrument identifier of the leg security.
DepositType::Enum depositType() const
DepositType.
const Tag InstrumentPartyRoleQualifier
Definition: Tags.h:234
bool settlCurrency(StringRef &desc) const
Settlement currency.
const Tag InstrumentPartyRole
Definition: Tags.h:233
StringRef issuer() const
Issuer of instrument.
bool transactTime(UInt64 &time) const
Transact Time.
bool securityDesc(StringRef &desc) const
Security description.
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:232
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:102
unsigned int UInt32
Definition: Numeric.h:41
Definition: Defines.h:30
Decimal type for better precision.
Definition: Numeric.h:63
const Tag InstrumentPricePrecision
Definition: Tags.h:165
TradingSessionSubID::Enum tradingSessionSubID() const
Defines the trading session sub ID.
Indicates timestamp in "YYYYMMDD" format.
Definition: Timestamp.h:66
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:132
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.
bool issueDate(UInt32 &date) const
Issue date of instrument.
const Tag StrikePricePrecision
Definition: Tags.h:164
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.
FlatIndicator::Enum flatIndicator() const
The Flat Indicator of a bond.
Represents timestamp without time-zone information.
Definition: Timestamp.h:80
bool maturityMonthYear(UInt32 &monthYear) const
Expiration month (YYYYMM).
SecurityType::Enum securityType() const
Type of security.
bool strikePricePrecision(UInt32 &precision) const
Strike Price Precision.
SettlSubMethod::Enum settlSubMethod() const
const Tag SecurityAltIDSource
Definition: Tags.h:70
bool settlBusinessDays(UInt32 &value) const
Settlment 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�s settlement price. Converted in trading notation in case of variance futures...
CouponType::Enum couponType() const
Coupon Type.
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:53
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:101
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:268
bool strikePrice(Decimal &price) const
Strike Price.
StringRef underlyingSymbol() const
Underlying symbol.
const Tag MinPriceIncrementClearing
Definition: Tags.h:238
bool refTickTableID(UInt32 &time) const
Reference to tick size table identifier from product level message.
const Tag MaturityMonthYear
Definition: Tags.h:48
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.
bool assetType(UInt32 &val) const
AssetType.
const Tag SecurityExchange
Definition: Tags.h:52
bool maturityDate(Timestamp &date) const
Actual expiration day of the instrument (YYYYMMDD).
Exposes list of available security types.