OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  8.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  ///
482  EligibleForSystematicInternaliser = 16,
483  ///
484  MultiCCPEligible = 17,
485  ///
487  ///
489  ///
491  ///
493  ///
495  ///
497  ///
499  ///
501  ///
503  ///
505  ///
506  SpecialistUserGroup
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  class InstrumentParties : public TypedGroup<InstrumentParty>
559  {
560  private:
561  explicit
562  InstrumentParties (const Group& group)
564  {
565  }
566 
567  friend class InstrumentSnapshot;
568  };
569 
570  /// Instrument Attribute.
571  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
572  {
573  public:
574 
575  ///
577  {
578  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
579  }
580 
581  ///
582  StringRef value() const
583  {
584  StringRef val;
585  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
586  }
587 
588  private:
590 
591  InstrumentAttribute (const GroupInstance& groupInstance)
592  : GroupInstance (groupInstance)
593  {
594  }
595  };
596 
597  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
598  {
599  private:
600  explicit
601  InstrumentAttributes (const Group& group)
603  {
604  }
605 
606  friend class InstrumentSnapshot;
607  };
608 
609 
610  /// Event.
611  class ONIXS_EUREX_EMDI_API Event : GroupInstance
612  {
613  public:
614  /// Event Type
615  bool eventType (UInt32& type) const
616  {
617  return get (Tags::EventType).toNumber (type);
618  }
619 
620  /// Event Date
622  {
623  return getUInt32 (Tags::EventDate);
624  }
625 
626  private:
627  friend class TypedGroup<Event>;
628 
629  Event (const GroupInstance& groupInstance)
630  : GroupInstance (groupInstance)
631  {
632  }
633  };
634 
635  class Events : public TypedGroup<Event>
636  {
637  private:
638  explicit
639  Events (const Group& group)
640  : TypedGroup<Event> (group)
641  {
642  }
643 
644  friend class InstrumentSnapshot;
645  };
646 
647  ///
648  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
649  {
650  private:
651  explicit
652  InstrumentSnapshotLegs (const Group& group)
653  : TypedGroup<InstrumentLeg> (group)
654  {
655  }
656 
657  friend class InstrumentSnapshot;
658  };
659 
660 
661  /// TradingSessionRules
662  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
663  {
664  public:
665 
666  /// Trading Session ID
668  {
669  return 0u;
670  }
671 
672  /// Defines the trading session sub ID.
674  {
675  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
676  }
677 
678  private:
680 
681  TradingSessionRule (const GroupInstance& groupInstance)
682  : GroupInstance (groupInstance)
683  {
684  }
685  };
686 
687  ///
688  class TradingSessionRules : public TypedGroup<TradingSessionRule>
689  {
690  private:
691  explicit
692  TradingSessionRules (const Group& group)
694  {
695  }
696 
697  friend class InstrumentSnapshot;
698  };
699 
700  /// Instrument snapshot.
701  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
702  {
703  public:
704  /// Instrument identifier.
706  {
707  return getInt64 (Tags::SecurityID);
708  }
709 
710  /// Entries.
712  {
713  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
714  }
715 
716  /// Type of security.
718  {
719  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
720  }
721 
722  /// Security Status.
724  {
725  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
726  }
727 
728  /// Security description
729  bool securityDesc(StringRef& desc) const
730  {
731  return get (Tags::SecurityDesc).toStringRef (desc);
732  }
733 
734  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
735  bool securityExchange (StringRef& exchange) const
736  {
737  return get (Tags::SecurityExchange).toStringRef (exchange);
738  }
739 
740  /// Type of Market Data update action
742  {
743  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
744  }
745 
746  /// Indicates the type of security using ISO 10962 standard.
747  bool cfiCode(StringRef desc) const
748  {
749  return get (Tags::CFICode).toStringRef (desc);
750  }
751 
752  /// Actual contract start date
753  bool contractDate (UInt32& value)
754  {
755  return get (Tags::ContractDate).toNumber (value);
756  }
757 
758  /// Contract start month
759  bool contractMonthYear (UInt32& value)
760  {
761  return get (Tags::ContractMonthYear).toNumber (value);
762  }
763 
764  /// Strike Price
765  bool strikePrice (Decimal& price) const
766  {
767  return get (Tags::StrikePrice).toNumber (price);
768  }
769 
770  /// Strike Price Precision
771  bool strikePricePrecision (UInt32& precision) const
772  {
773  return get (Tags::StrikePricePrecision).toNumber (precision);
774  }
775 
776  /// Contract Multiplier
777  bool contractMultiplier (Decimal& multiplier) const
778  {
779  return get (Tags::ContractMultiplier).toNumber (multiplier);
780  }
781 
782  /// Put Or Call
784  {
785  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
786  }
787 
788  /// Version of an option. Version can change as a result of corporate actions or events.
789  bool optAttribute (UInt32& attribute) const
790  {
791  return get (Tags::OptAttribute).toNumber (attribute);
792  }
793 
794  /// Exercise Style
796  {
797  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
798  }
799 
800  /// Original strike price prior to corporate action, e.g. 5.20.
801  bool origStrikePrice (Decimal& price) const
802  {
803  return get (Tags::OrigStrikePrice).toNumber (price);
804  }
805 
806  /// Contract generation.
807  bool contractGenerationNumber (UInt32& number) const
808  {
809  return get (Tags::ContractGenerationNumber).toNumber (number);
810  }
811 
812  /// Lepo Flag
814  {
815  UInt32 value;
816  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
817  }
818 
819  /// Traditional or futures margin style.
821  {
822  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
823  }
824 
825  ///
827  {
828  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
829  }
830 
831  ///
833  {
834  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
835  }
836 
837  /// Previous day�s settlement price. Converted in trading notation in case of variance futures.
838  bool priorSettlPrice (Decimal& price) const
839  {
840  return get (Tags::PriorSettlPrice).toNumber (price);
841  }
842 
843  /// Legs
845  {
846  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
847  }
848 
849  /// UnitOfMeasure
850  bool unitOfMeasure(StringRef& val) const
851  {
852  return get(Tags::UnitOfMeasure).toStringRef(val);
853  }
854 
855  /// AssetType
856  bool assetType(UInt32& val) const
857  {
858  return get(Tags::AssetType).toNumber(val);
859  }
860 
861  /// AssetSubType
862  bool assetSubType(UInt32& val) const
863  {
864  return get(Tags::AssetSubType).toNumber(val);
865  }
866 
867  /// Transact Time
868  bool transactTime (UInt64& time) const
869  {
870  return get (Tags::TransactTime).toNumber (time);
871  }
872 
873  /// Reference to tick size table identifier from product level message.
874  bool refTickTableID (UInt32& time) const
875  {
876  return get (Tags::RefTickTableID).toNumber (time);
877  }
878 
879  /// Currency as published in ISO 4217.
881  {
882  return getStringRef (Tags::Currency);
883  }
884 
885  /// Settlement currency.
886  bool settlCurrency(StringRef& desc) const
887  {
888  return get (Tags::SettlCurrency).toStringRef (desc);
889  }
890 
891  /// DepositType
893  {
894  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
895  }
896 
897  /// Issuer of instrument.
899  {
900  return getStringRef(Tags::Issuer);
901  }
902 
903  /// Issue date of instrument.
904  bool issueDate(UInt32& date) const
905  {
906  return get(Tags::IssueDate).toNumber(date);
907  }
908 
909  ///
910  bool roundLot(Decimal& value) const
911  {
912  return get(Tags::RoundLot).toNumber(value);
913  }
914 
915  /// The minimum tradable unit of a bond.
916  bool minTradeVol(Decimal& value) const
917  {
918  return get(Tags::MinTradeVol).toNumber(value);
919  }
920 
921  /// QuotingStartTime
922  bool quotingStartTime(StringRef value) const
923  {
924  return get(Tags::QuotingStartTime).toStringRef(value);
925  }
926 
927  /// QuotingEndTime
928  bool quotingEndTime(StringRef value) const
929  {
930  return get(Tags::QuotingEndTime).toStringRef(value);
931  }
932 
933  /// InstrumentAuctionType
935  {
936  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
937  }
938 
939  /// Instrument parties.
941  {
942  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
943  }
944 
945  /// Underlying symbol.
947  {
948  return getStringRef(Tags::UnderlyingSymbol);
949  }
950 
951  /// Instrument identifier of the leg security.
952  bool couponRate(Decimal& value) const
953  {
954  return get(Tags::CouponRate).toNumber(value);
955  }
956 
957  /// Previous coupon payment date.
959  {
960  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
961  }
962 
963  /// Upcoming Coupon payment date.
964  bool couponPaymentDate(UInt32& value) const
965  {
966  return get(Tags::CouponPaymentDate).toNumber(value);
967  }
968 
969  /// Defines the Accrued interest Calculation Method.
971  {
972  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
973  }
974 
975  /// Coupon Type
977  {
978  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
979  }
980 
981  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
983  {
984  return getStringRef(Tags::CountryOfIssue);
985  }
986 
987  /// The Flat Indicator of a bond.
989  {
990  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
991  }
992 
993  /// WarrantType
995  {
996  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
997  }
998 
999  /// Instrument attributes
1001  {
1002  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1003  }
1004 
1005  /// Events.
1006  Events events() const
1007  {
1008  return Events ( getGroup (Tags::NoEvents) );
1009  }
1010 
1011  /// Instrument Price Precision
1012  bool instrumentPricePrecision (UInt32& value) const
1013  {
1014  return get (Tags::InstrumentPricePrecision).toNumber (value);
1015  }
1016 
1017  /// Defines the minimum price movement in ticks (tick size).
1018  bool minPriceIncrement (Decimal& increment) const
1019  {
1020  return get (Tags::MinPriceIncrement).toNumber (increment);
1021  }
1022 
1023  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1025  {
1026  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1027  }
1028 
1029  /// Defines the minimum price movement in the respective currency (tick value).
1031  {
1032  return getDecimal (Tags::MinPriceIncrementAmount);
1033  }
1034 
1035  /// Actual expiration day of the instrument (YYYYMMDD).
1036  bool maturityDate(Timestamp& date) const
1037  {
1038  UInt32 tmp;
1039  if (get(Tags::MaturityDate).toNumber(tmp))
1040  {
1042  return true;
1043  }
1044  return false;
1045  }
1046 
1047  /// Expiration month (YYYYMM).
1048  bool maturityMonthYear(UInt32& monthYear) const
1049  {
1050  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1051  }
1052 
1053  /// Standard strategy type for complex instruments.
1054  bool securitySubType(UInt32& type) const
1055  {
1056  return get(Tags::SecuritySubType).toNumber(type);
1057  }
1058 
1059  /// Product identifier.
1061  {
1062  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1063  }
1064 
1065  /// Implied market indicator
1067  {
1068  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1069  }
1070 
1071  /// Multileg model
1073  {
1074  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1075  }
1076 
1077  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1079  {
1080  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1081  }
1082 
1083  /// Only for cash.
1085  {
1086  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1087  }
1088 
1089  /// Settlment Business Days
1090  bool settlBusinessDays (UInt32& value) const
1091  {
1092  return get (Tags::SettlBusinessDays).toNumber (value);
1093  }
1094 
1095  /// Bid side minimum quote quantity.
1097  {
1098  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1099  }
1100 
1101  /// Bid side minimum quote quantity.
1102  bool quoteSizeMinOfferSize(Decimal& value) const
1103  {
1104  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1105  }
1106 
1107  /// Bid side minimum quote quantity.
1109  {
1110  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1111  }
1112 
1113  ///
1114  bool symbol(StringRef value) const
1115  {
1116  return get(Tags::Symbol).toStringRef(value);
1117  }
1118 
1119  ///
1121  {
1122  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1123  }
1124 
1125  private:
1128 
1129  InstrumentSnapshot (const void* impl)
1130  : Message (impl)
1131  {
1132  }
1133  };
1134  }
1135  }
1136 }
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: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.
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
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:77
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 InstrumentPricePrecision
Definition: Tags.h:149
TradingSessionSubID::Enum tradingSessionSubID() const
Defines the trading session sub ID.
Indicates timestamp in "YYYYMMDD" format.
Definition: Timestamp.h:66
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.
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 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: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:68
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.
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.
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.