OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  7.4.2
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  class Events : public TypedGroup<Event>
582  {
583  private:
584  explicit
585  Events (const Group& group)
586  : TypedGroup<Event> (group)
587  {
588  }
589 
590  friend class InstrumentSnapshot;
591  };
592 
593  ///
594  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
595  {
596  private:
597  explicit
598  InstrumentSnapshotLegs (const Group& group)
599  : TypedGroup<InstrumentLeg> (group)
600  {
601  }
602 
603  friend class InstrumentSnapshot;
604  };
605 
606 
607  /// TradingSessionRules
608  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
609  {
610  public:
611 
612  /// Trading Session ID
614  {
615  return 0u;
616  }
617 
618  /// Defines the trading session sub ID.
620  {
621  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
622  }
623 
624  private:
626 
627  TradingSessionRule (const GroupInstance& groupInstance)
628  : GroupInstance (groupInstance)
629  {
630  }
631  };
632 
633  ///
634  class TradingSessionRules : public TypedGroup<TradingSessionRule>
635  {
636  private:
637  explicit
638  TradingSessionRules (const Group& group)
640  {
641  }
642 
643  friend class InstrumentSnapshot;
644  };
645 
646  /// Instrument snapshot.
647  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
648  {
649  public:
650  /// Instrument identifier.
652  {
653  return getInt64 (Tags::SecurityID);
654  }
655 
656  /// Entries.
658  {
659  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
660  }
661 
662  /// Type of security.
664  {
665  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
666  }
667 
668  /// Security Status.
670  {
671  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
672  }
673 
674  /// Security description
675  bool securityDesc(StringRef& desc) const
676  {
677  return get (Tags::SecurityDesc).toStringRef (desc);
678  }
679 
680  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
681  bool securityExchange (StringRef& exchange) const
682  {
683  return get (Tags::SecurityExchange).toStringRef (exchange);
684  }
685 
686  /// Type of Market Data update action
688  {
689  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
690  }
691 
692  /// Indicates the type of security using ISO 10962 standard.
693  bool cfiCode(StringRef desc) const
694  {
695  return get (Tags::CFICode).toStringRef (desc);
696  }
697 
698  /// Strike Price
699  bool strikePrice (Decimal& price) const
700  {
701  return get (Tags::StrikePrice).toNumber (price);
702  }
703 
704  /// Strike Price Precision
705  bool strikePricePrecision (UInt32& precision) const
706  {
707  return get (Tags::StrikePricePrecision).toNumber (precision);
708  }
709 
710  /// Contract Multiplier
711  bool contractMultiplier (Decimal& multiplier) const
712  {
713  return get (Tags::ContractMultiplier).toNumber (multiplier);
714  }
715 
716  /// Put Or Call
718  {
719  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
720  }
721 
722  /// Version of an option. Version can change as a result of corporate actions or events.
723  bool optAttribute (UInt32& attribute) const
724  {
725  return get (Tags::OptAttribute).toNumber (attribute);
726  }
727 
728  /// Exercise Style
730  {
731  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
732  }
733 
734  /// Original strike price prior to corporate action, e.g. 5.20.
735  bool origStrikePrice (Decimal& price) const
736  {
737  return get (Tags::OrigStrikePrice).toNumber (price);
738  }
739 
740  /// Contract generation.
741  bool contractGenerationNumber (UInt32& number) const
742  {
743  return get (Tags::ContractGenerationNumber).toNumber (number);
744  }
745 
746  /// Lepo Flag
748  {
749  UInt32 value;
750  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
751  }
752 
753  /// Traditional or futures margin style.
755  {
756  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
757  }
758 
759  ///
761  {
762  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
763  }
764 
765  ///
767  {
768  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
769  }
770 
771  /// Previous day�s settlement price. Converted in trading notation in case of variance futures.
772  bool priorSettlPrice (Decimal& price) const
773  {
774  return get (Tags::PriorSettlPrice).toNumber (price);
775  }
776 
777  /// Legs
779  {
780  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
781  }
782 
783  /// UnitOfMeasure
784  bool unitOfMeasure(StringRef& val) const
785  {
786  return get(Tags::UnitOfMeasure).toStringRef(val);
787  }
788 
789  /// AssetType
790  bool assetType(UInt32& val) const
791  {
792  return get(Tags::AssetType).toNumber(val);
793  }
794 
795  /// AssetSubType
796  bool assetSubType(UInt32& val) const
797  {
798  return get(Tags::AssetSubType).toNumber(val);
799  }
800 
801  /// Transact Time
802  bool transactTime (UInt64& time) const
803  {
804  return get (Tags::TransactTime).toNumber (time);
805  }
806 
807  /// Reference to tick size table identifier from product level message.
808  bool refTickTableID (UInt32& time) const
809  {
810  return get (Tags::RefTickTableID).toNumber (time);
811  }
812 
813  /// Currency as published in ISO 4217.
815  {
816  return getStringRef (Tags::Currency);
817  }
818 
819  /// Settlement currency.
820  bool settlCurrency(StringRef& desc) const
821  {
822  return get (Tags::SettlCurrency).toStringRef (desc);
823  }
824 
825  /// DepositType
827  {
828  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
829  }
830 
831  /// Issuer of instrument.
833  {
834  return getStringRef(Tags::Issuer);
835  }
836 
837  /// Issue date of instrument.
838  bool issueDate(UInt32& date) const
839  {
840  return get(Tags::IssueDate).toNumber(date);
841  }
842 
843  ///
844  bool roundLot(Decimal& value) const
845  {
846  return get(Tags::RoundLot).toNumber(value);
847  }
848 
849  /// The minimum tradable unit of a bond.
850  bool minTradeVol(Decimal& value) const
851  {
852  return get(Tags::MinTradeVol).toNumber(value);
853  }
854 
855  /// Instrument parties.
857  {
858  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
859  }
860 
861  /// Underlying symbol.
863  {
864  return getStringRef(Tags::UnderlyingSymbol);
865  }
866 
867  /// Instrument identifier of the leg security.
868  bool couponRate(Decimal& value) const
869  {
870  return get(Tags::CouponRate).toNumber(value);
871  }
872 
873  /// Previous coupon payment date.
875  {
876  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
877  }
878 
879  /// Upcoming Coupon payment date.
880  bool couponPaymentDate(UInt32& value) const
881  {
882  return get(Tags::CouponPaymentDate).toNumber(value);
883  }
884 
885  /// Defines the Accrued interest Calculation Method.
887  {
888  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
889  }
890 
891  /// Coupon Type
893  {
894  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
895  }
896 
897  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
899  {
900  return getStringRef(Tags::CountryOfIssue);
901  }
902 
903  /// The Flat Indicator of a bond.
905  {
906  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
907  }
908 
909  /// Instrument attributes
911  {
912  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
913  }
914 
915  /// Events.
916  Events events() const
917  {
918  return Events ( getGroup (Tags::NoEvents) );
919  }
920 
921  /// Instrument Price Precision
922  bool instrumentPricePrecision (UInt32& value) const
923  {
924  return get (Tags::InstrumentPricePrecision).toNumber (value);
925  }
926 
927  /// Defines the minimum price movement in ticks (tick size).
928  bool minPriceIncrement (Decimal& increment) const
929  {
930  return get (Tags::MinPriceIncrement).toNumber (increment);
931  }
932 
933  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
934  bool minPriceIncrementClearing (Decimal& price) const
935  {
936  return get (Tags::MinPriceIncrementClearing).toNumber (price);
937  }
938 
939  /// Defines the minimum price movement in the respective currency (tick value).
941  {
942  return getDecimal (Tags::MinPriceIncrementAmount);
943  }
944 
945  /// Actual expiration day of the instrument (YYYYMMDD).
946  bool maturityDate(Timestamp& date) const
947  {
948  UInt32 tmp;
949  if (get(Tags::MaturityDate).toNumber(tmp))
950  {
952  return true;
953  }
954  return false;
955  }
956 
957  /// Expiration month (YYYYMM).
958  bool maturityMonthYear(UInt32& monthYear) const
959  {
960  return get(Tags::MaturityMonthYear).toNumber(monthYear);
961  }
962 
963  /// Standard strategy type for complex instruments.
964  bool securitySubType(UInt32& type) const
965  {
966  return get(Tags::SecuritySubType).toNumber(type);
967  }
968 
969  /// Product identifier.
971  {
972  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
973  }
974 
975  /// Implied market indicator
977  {
978  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
979  }
980 
981  /// Multileg model
983  {
984  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
985  }
986 
987  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
989  {
990  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
991  }
992 
993  /// Only for cash.
995  {
996  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
997  }
998 
999  /// Settlment Business Days
1000  bool settlBusinessDays (UInt32& value) const
1001  {
1002  return get (Tags::SettlBusinessDays).toNumber (value);
1003  }
1004 
1005  /// Bid side minimum quote quantity.
1007  {
1008  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1009  }
1010 
1011  /// Bid side minimum quote quantity.
1012  bool quoteSizeMinOfferSize(Decimal& value) const
1013  {
1014  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1015  }
1016 
1017  /// Bid side minimum quote quantity.
1019  {
1020  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1021  }
1022 
1023  ///
1024  bool symbol(StringRef value) const
1025  {
1026  return get(Tags::Symbol).toStringRef(value);
1027  }
1028 
1029  ///
1031  {
1032  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1033  }
1034 
1035  private:
1038 
1039  InstrumentSnapshot (const void* impl)
1040  : Message (impl)
1041  {
1042  }
1043  };
1044  }
1045  }
1046 }
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.