OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  7.0.3
API documentation
InstrumentSnapshot.h
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable OnixS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #pragma once
21 
27 
28 namespace OnixS
29 {
30  namespace Eurex
31  {
32  namespace MarketData
33  {
34 
35  /// Alternate identifier entry.
36  class ONIXS_EUREX_EMDI_API SecurityAlt : GroupInstance
37  {
38  public:
39 
40  /// Alternate instrument identifier.
42  {
43  StringRef val;
44  return get (Tags::SecurityAltID).toStringRef (val) ? val : StringRef();
45  }
46 
47  /// Security alternate id source.
49  {
50  StringRef val;
51  return get (Tags::SecurityAltIDSource).toStringRef (val) ? val : StringRef();
52  }
53 
54  private:
55  friend class TypedGroup<SecurityAlt>;
56 
57  SecurityAlt (const GroupInstance& groupInstance)
58  : GroupInstance (groupInstance)
59  {
60  }
61  };
62 
63  class SecurityAlts : public TypedGroup<SecurityAlt>
64  {
65  private:
66  SecurityAlts (const Group& group)
67  : TypedGroup<SecurityAlt> (group)
68  {
69  }
70 
71  friend class InstrumentSnapshot;
72  };
73 
74  /// Exposes list of available security types.
75  struct ONIXS_EUREX_EMDI_API SecurityType
76  {
77  enum Enum
78  {
79  /// Used to identify absence of value.
80  Undefined = -1,
81 
82  ///
83  Option = 0,
84 
85  ///
86  Future = 1,
87 
88  ///
89  MultiLegInstrument = 2,
90 
91  ///
92  VarianceFutures = 3,
93 
94  ///
95  TotalReturnFutures = 4,
96 
97  ///
98  CommonStock = 5,
99 
100  ///
101  Bond = 6,
102 
103  ///
104  TradeAtReferencePrice = 7,
105 
106  ///
107  ExchangeTradedFund = 8,
108 
109  ///
110  ExchangeTradedCommodity = 9,
111 
112  ///
113  ExchangeTradedNote = 10,
114 
115  ///
117 
118  ///
120  };
121  };
122 
123  /// Exposes list of Instrument scope operators.
124  struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
125  {
126  enum Enum
127  {
128  /// Used to identify absence of value.
129  Undefined = -1,
130 
131  ///
132  Include = 0,
133  };
134  };
135 
136 
137  ///
138  struct ONIXS_EUREX_EMDI_API PutOrCall
139  {
140  enum Enum
141  {
142  /// Used to identify absence of value.
143  Undefined = -1,
144 
145  ///
146  Put = 0,
147 
148  ///
149  Call = 1
150  };
151  };
152 
153 
154  ///
155  struct ONIXS_EUREX_EMDI_API ExerciseStyle
156  {
157  enum Enum
158  {
159  /// Used to identify absence of value.
160  Undefined = -1,
161 
162  ///
163  European = 0,
164 
165  ///
166  American = 1
167  };
168  };
169 
170  struct ONIXS_EUREX_EMDI_API MultilegModel
171  {
172  enum Enum
173  {
174  /// Used to identify absence of value.
175  Undefined = -1,
176 
177  ///
178  PredefinedMultilegSecurity = 0,
179 
180  ///
181  UserDefinedMultilegSecurity = 1
182  };
183  };
184 
185  ///
186  struct ONIXS_EUREX_EMDI_API ValuationMethod
187  {
188  enum Enum
189  {
190  /// Used to identify absence of value.
191  Undefined = -1,
192 
193  ///
194  PremiumStyle = 0,
195 
196  ///
197  FuturesStyleMarkToMarket = 1
198  };
199  };
200 
201  struct ONIXS_EUREX_EMDI_API SettlMethod
202  {
203  enum Enum
204  {
205  /// Used to identify absence of value.
206  Undefined = -1,
207 
208  ///
209  Cash = 0,
210 
211  ///
212  Physical = 1
213  };
214  };
215 
216  struct ONIXS_EUREX_EMDI_API SettlSubMethod
217  {
218  enum Enum
219  {
220  /// Used to identify absence of value.
221  Undefined = -1,
222 
223  ///
224  Shares = 0,
225  Derivatives = 1,
226  PaymentVsPayment = 2,
227  Notional = 3,
228  Cascade = 4,
229  Other = 5
230  };
231  };
232 
233  struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
234  {
235  enum Enum
236  {
237  /// Used to identify absence of value.
238  Undefined = -1,
239 
240  ///
241  Proprietary = 0,
242  };
243  };
244 
245  struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
246  {
247  enum Enum
248  {
249  /// Used to identify absence of value.
250  Undefined = -1,
251 
252  ///
253  ClearingOrganization = 0,
254  ///
255  MarketMaker = 1,
256  };
257  };
258 
259  struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
260  {
261  enum Enum
262  {
263  /// Used to identify absence of value.
264  Undefined = -1,
265 
266  ///
267  DesignatedSponsor = 0,
268  };
269  };
270 
271  /// Deposit Type
272  struct ONIXS_EUREX_EMDI_API DepositType
273  {
274  enum Enum
275  {
276  /// Used to identify absence of value.
277  Undefined = -1,
278 
279  ///
280  Auslandskassenverein = 0,
281 
282  ///
283  Girosammelverwahrung = 1,
284 
285  ///
286  Streifbandverwahrung = 2,
287 
288  ///
289  Wertpapierrechnung = 3,
290  };
291  };
292 
293  /// Accrued interest Calculation Methods
294  struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
295  {
296  enum Enum
297  {
298  /// Used to identify absence of value.
299  Undefined = -1,
300 
301  ///
302  Basis30360 = 0,
303 
304  ///
306 
307  ///
309 
310  ///
312 
313  ///
315 
316  ///
318 
319  ///
321 
322  ///
324  };
325  };
326 
327  /// Coupon Types
328  struct ONIXS_EUREX_EMDI_API CouponType
329  {
330  enum Enum
331  {
332  /// Used to identify absence of value.
333  Undefined = -1,
334 
335  ///
336  Zero = 0,
337 
338  ///
340 
341  ///
343 
344  ///
346  };
347  };
348 
349  /// Flat Indicators
350  struct ONIXS_EUREX_EMDI_API FlatIndicator
351  {
352  enum Enum
353  {
354  /// Used to identify absence of value.
355  Undefined = -1,
356 
357  ///
358  NoFlat = 0,
359 
360  ///
362 
363  ///
365  };
366  };
367 
368  /// Instrument Party.
369  class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
370  {
371  public:
372 
373  /// Identifies a party associated with an instrument.
374  StringRef id() const
375  {
376  StringRef val;
377  return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
378  }
379 
380  ///
382  {
383  return getIntEnumFieldValue<InstrumentPartyIDSource> (*this, Tags::InstrumentPartyIDSource);
384  }
385 
386  ///
388  {
389  return getIntEnumFieldValue<InstrumentPartyRole> (*this, Tags::InstrumentPartyRole);
390  }
391 
392  ///
394  {
395  return getIntEnumFieldValue<InstrumentPartyRoleQualifier> (*this, Tags::InstrumentPartyRoleQualifier);
396  }
397 
398  private:
400 
401  InstrumentParty (const GroupInstance& groupInstance)
402  : GroupInstance (groupInstance)
403  {
404  }
405  };
406 
407  struct ONIXS_EUREX_EMDI_API InstrumentAttributeType
408  {
409  enum Enum
410  {
411  /// Used to identify absence of value.
412  Undefined = -1,
413 
414  ///
415  MinimumReserveOrderQuantity = 0,
416  ///
417  MinimumDisplayQuantity = 1,
418  ///
419  IssuerName = 2,
420  ///
421  IssuerNumber = 3,
422  ///
423  MarketType = 4,
424  ///
425  MarketTypeSupplement = 5,
426  ///
427  ReportingMarket = 6,
428  ///
429  CumExIndicator = 7,
430  ///
431  ProductAssignmentGroup = 8,
432  ///
433  ProductAssignmentGroupDescription = 9,
434  ///
435  PreTradeLISValue = 10,
436  ///
437  VDOMinimumExecutionVolume = 11,
438  ///
439  IlliquidAsDefinedByExchange = 12,
440  ///
441  MarketMakingObligation = 13,
442  ///
443  LiquidAsDefinedByRegulator = 14,
444  ///
445  EligibleForStressedMarketConditions = 15,
446  ///
447  EligibleForSystematicInternaliser = 16,
448  ///
449  MultiCCPEligible = 17,
450  ///
452  ///
454  ///
456  ///
458  ///
460  ///
462  ///
464  ///
466  };
467  };
468 
469  struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
470  {
471  enum Enum
472  {
473  /// Used to identify absence of value.
474  Undefined = -1,
475 
476  ///
477  Disabled = 0,
478  ///
479  Enabled = 1,
480  ///
481  CentralCounterparty = 2,
482  };
483  };
484 
485  struct ONIXS_EUREX_EMDI_API PriceType
486  {
487  enum Enum
488  {
489  /// Used to identify absence of value.
490  Undefined = -1,
491 
492  ///
493  Percent = 0,
494  ///
495  Shares = 1,
496  ///
497  Points = 2,
498  };
499  };
500 
501  class InstrumentParties : public TypedGroup<InstrumentParty>
502  {
503  private:
504  InstrumentParties (const Group& group)
506  {
507  }
508 
509  friend class InstrumentSnapshot;
510  };
511 
512  /// Instrument Attribute.
513  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
514  {
515  public:
516 
517  ///
519  {
520  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
521  }
522 
523  ///
524  StringRef value() const
525  {
526  StringRef val;
527  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
528  }
529 
530  private:
532 
533  InstrumentAttribute (const GroupInstance& groupInstance)
534  : GroupInstance (groupInstance)
535  {
536  }
537  };
538 
539  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
540  {
541  private:
542  InstrumentAttributes (const Group& group)
544  {
545  }
546 
547  friend class InstrumentSnapshot;
548  };
549 
550 
551  /// Event.
552  class ONIXS_EUREX_EMDI_API Event : GroupInstance
553  {
554  public:
555 
556  /// Event Type
557  bool eventType (UInt32& type) const
558  {
559  return get (Tags::EventType).toNumber (type);
560  }
561 
562  /// Event Date
564  {
565  return getUInt32 (Tags::EventDate);
566  }
567 
568  private:
569  friend class TypedGroup<Event>;
570 
571  Event (const GroupInstance& groupInstance)
572  : GroupInstance (groupInstance)
573  {
574  }
575  };
576 
577  class Events : public TypedGroup<Event>
578  {
579  private:
580  Events (const Group& group)
581  : TypedGroup<Event> (group)
582  {
583  }
584 
585  friend class InstrumentSnapshot;
586  };
587 
588  ///
589  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
590  {
591  private:
592  InstrumentSnapshotLegs (const Group& group)
593  : TypedGroup<InstrumentLeg> (group)
594  {
595  }
596 
597  friend class InstrumentSnapshot;
598  };
599 
600 
601  /// TradingSessionRules
602  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
603  {
604  public:
605 
606  /// Trading Session ID
608  {
609  return 0;
610  }
611 
612  /// Defines the trading session sub ID.
614  {
615  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
616  }
617 
618  private:
620 
621  TradingSessionRule (const GroupInstance& groupInstance)
622  : GroupInstance (groupInstance)
623  {
624  }
625  };
626 
627  ///
628  class TradingSessionRules : public TypedGroup<TradingSessionRule>
629  {
630  private:
631  TradingSessionRules (const Group& group)
633  {
634  }
635 
636  friend class InstrumentSnapshot;
637  };
638 
639  /// Instrument snapshot.
640  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
641  {
642  public:
643  /// Instrument identifier.
645  {
646  return getInt64 (Tags::SecurityID);
647  }
648 
649  /// Entries.
651  {
652  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
653  }
654 
655  /// Type of security.
657  {
658  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
659  }
660 
661  /// Security Status.
663  {
664  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
665  }
666 
667  /// Security description
668  bool securityDesc(StringRef& desc) const
669  {
670  return get (Tags::SecurityDesc).toStringRef (desc);
671  }
672 
673  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
674  bool securityExchange (StringRef& exchange) const
675  {
676  return get (Tags::SecurityExchange).toStringRef (exchange);
677  }
678 
679  /// Type of Market Data update action
681  {
682  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
683  }
684 
685  /// Indicates the type of security using ISO 10962 standard.
686  bool cfiCode(StringRef desc) const
687  {
688  return get (Tags::CFICode).toStringRef (desc);
689  }
690 
691  /// Strike Price
692  bool strikePrice (Decimal& price) const
693  {
694  return get (Tags::StrikePrice).toNumber (price);
695  }
696 
697  /// Strike Price Precision
698  bool strikePricePrecision (UInt32& precision) const
699  {
700  return get (Tags::StrikePricePrecision).toNumber (precision);
701  }
702 
703  /// Contract Multiplier
704  bool contractMultiplier (Decimal& multiplier) const
705  {
706  return get (Tags::ContractMultiplier).toNumber (multiplier);
707  }
708 
709  /// Put Or Call
711  {
712  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
713  }
714 
715  /// Version of an option. Version can change as a result of corporate actions or events.
716  bool optAttribute (UInt32& attribute) const
717  {
718  return get (Tags::OptAttribute).toNumber (attribute);
719  }
720 
721  /// Exercise Style
723  {
724  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
725  }
726 
727  /// Original strike price prior to corporate action, e.g. 5.20.
728  bool origStrikePrice (Decimal& price) const
729  {
730  return get (Tags::OrigStrikePrice).toNumber (price);
731  }
732 
733  /// Contract generation.
734  bool contractGenerationNumber (UInt32& number) const
735  {
736  return get (Tags::ContractGenerationNumber).toNumber (number);
737  }
738 
739  /// Lepo Flag
741  {
742  UInt32 value;
743  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
744  }
745 
746  /// Traditional or futures margin style.
748  {
749  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
750  }
751 
752  ///
754  {
755  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
756  }
757 
758  ///
760  {
761  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
762  }
763 
764  /// Previous day�s settlement price. Converted in trading notation in case of variance futures.
765  bool priorSettlPrice (Decimal& price) const
766  {
767  return get (Tags::PriorSettlPrice).toNumber (price);
768  }
769 
770  /// Legs
772  {
773  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
774  }
775 
776  /// UnitOfMeasure
777  bool unitOfMeasure(StringRef& val) const
778  {
779  return get(Tags::UnitOfMeasure).toStringRef(val);
780  }
781 
782  /// AssetType
783  bool assetType(UInt32& val) const
784  {
785  return get(Tags::AssetType).toNumber(val);
786  }
787 
788  /// AssetSubType
789  bool assetSubType(UInt32& val) const
790  {
791  return get(Tags::AssetSubType).toNumber(val);
792  }
793 
794  /// Transact Time
795  bool transactTime (UInt64& time) const
796  {
797  return get (Tags::TransactTime).toNumber (time);
798  }
799 
800  /// Reference to tick size table identifier from product level message.
801  bool refTickTableID (UInt32& time) const
802  {
803  return get (Tags::RefTickTableID).toNumber (time);
804  }
805 
806  /// Currency as published in ISO 4217.
808  {
809  return getStringRef (Tags::Currency);
810  }
811 
812  /// Settlement currency.
813  bool settlCurrency(StringRef& desc) const
814  {
815  return get (Tags::SettlCurrency).toStringRef (desc);
816  }
817 
818  /// DepositType
820  {
821  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
822  }
823 
824  /// Issuer of instrument.
826  {
827  return getStringRef(Tags::Issuer);
828  }
829 
830  /// Issue date of instrument.
831  bool issueDate(UInt32& date) const
832  {
833  return get(Tags::IssueDate).toNumber(date);
834  }
835 
836  /// Instrument parties.
838  {
839  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
840  }
841 
842 
843  /// Underlying symbol.
845  {
846  return getStringRef(Tags::UnderlyingSymbol);
847  }
848 
849  /// Instrument identifier of the leg security.
850  bool couponRate(Decimal& value) const
851  {
852  return get(Tags::CouponRate).toNumber(value);
853  }
854 
855  /// Previous coupon payment date.
857  {
858  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
859  }
860 
861  /// Upcoming Coupon payment date.
862  bool couponPaymentDate(UInt32& value) const
863  {
864  return get(Tags::CouponPaymentDate).toNumber(value);
865  }
866 
867  /// Defines the Accrued interest Calculation Method.
869  {
870  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
871  }
872 
873  /// Coupon Type
875  {
876  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
877  }
878 
879  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
881  {
882  return getStringRef(Tags::CountryOfIssue);
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  /// The Flat Indicator of a bond.
893  {
894  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
895  }
896 
897  /// Instrument attributes
899  {
900  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
901  }
902 
903  /// Events.
904  Events events() const
905  {
906  return Events ( getGroup (Tags::NoEvents) );
907  }
908 
909  /// Instrument Price Precision
910  bool instrumentPricePrecision (UInt32& value) const
911  {
912  return get (Tags::InstrumentPricePrecision).toNumber (value);
913  }
914 
915 
916  /// Defines the minimum price movement in ticks (tick size).
917  bool minPriceIncrement (Decimal& increment) const
918  {
919  return get (Tags::MinPriceIncrement).toNumber (increment);
920  }
921 
922  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
923  bool minPriceIncrementClearing (Decimal& price) const
924  {
925  return get (Tags::MinPriceIncrementClearing).toNumber (price);
926  }
927 
928  /// Defines the minimum price movement in the respective currency (tick value).
930  {
931  return getDecimal (Tags::MinPriceIncrementAmount);
932  }
933 
934  /// Actual expiration day of the instrument (YYYYMMDD).
935  bool maturityDate(Timestamp& date) const
936  {
937  UInt32 tmp;
938  if (get(Tags::MaturityDate).toNumber(tmp))
939  {
941  return true;
942  }
943  return false;
944  }
945 
946  /// Expiration month (YYYYMM).
947  bool maturityMonthYear(UInt32& monthYear) const
948  {
949  return get(Tags::MaturityMonthYear).toNumber(monthYear);
950  }
951 
952  /// Standard strategy type for complex instruments.
953  bool securitySubType(UInt32& type) const
954  {
955  return get(Tags::SecuritySubType).toNumber(type);
956  }
957 
958  /// Product identifier.
960  {
961  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
962  }
963 
964  /// Implied market indicator
966  {
967  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
968  }
969 
970  /// Multileg model
972  {
973  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
974  }
975 
976  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
978  {
979  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
980  }
981 
982  /// Only for cash.
984  {
985  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
986  }
987 
988  /// Settlment Business Days
989  bool settlBusinessDays (UInt32& value) const
990  {
991  return get (Tags::SettlBusinessDays).toNumber (value);
992  }
993 
994  /// Bid side minimum quote quantity.
995  bool quoteSizeRuleMinBidSize(Decimal& value) const
996  {
997  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
998  }
999 
1000  /// Bid side minimum quote quantity.
1001  bool quoteSizeMinOfferSize(Decimal& value) const
1002  {
1003  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1004  }
1005 
1006  /// Bid side minimum quote quantity.
1008  {
1009  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1010  }
1011 
1012  ///
1013  bool symbol(StringRef value) const
1014  {
1015  return get(Tags::Symbol).toStringRef(value);
1016  }
1017 
1018  ///
1020  {
1021  return getOptionalGroup(Tags::NoTradingSessionRules);
1022  }
1023 
1024 
1025  private:
1028 
1029  InstrumentSnapshot (const void* impl)
1030  : Message (impl)
1031  {
1032  }
1033  };
1034  }
1035  }
1036 }
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: Group.h:25
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.