OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  11.1.0
API documentation
ProductSnapshot.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 
28 
29 
30 namespace OnixS
31 {
32  namespace Eurex
33  {
34  namespace MarketData
35  {
36  /// Exposes list of available Quote side indicators.
37  struct ONIXS_EUREX_EMDI_API QuoteSideIndicator
38  {
39  enum Enum
40  {
41  /// Used to identify absence of value.
42  Undefined = -1,
43 
44  /// Not allowed
45  OneSidedQuoteNotAllowed = 0,
46 
47  /// Allowed
48  OneSidedQuoteAllowed = 1,
49  };
50  };
51 
52  /// Exposes list of available quote side model types.
53  struct ONIXS_EUREX_EMDI_API QuoteSideModelType
54  {
55  enum Enum
56  {
57  /// Used to identify absence of value.
58  Undefined = -1,
59 
60  /// Single-sided quotes not supported
61  SSQNotSupported = 0,
62 
63  /// Single-sided quotes supported
64  SSQSupported = 1,
65  };
66  };
67 
68  /// Exposes list of available feed types.
69  struct ONIXS_EUREX_EMDI_API FeedType
70  {
71  enum Enum
72  {
73  /// Used to identify absence of value.
74  Undefined = -1,
75 
76  /// Defines if product is traded on on NTA.
77  HighIncremental = 0,
78 
79  /// Defines if product is still traded on "Eurex classic"
80  HighSnapshot = 1,
81 
82  /// Defines if product is still traded on "Eurex classic"
83  Low = 2,
84  };
85  };
86 
87  class ONIXS_EUREX_EMDI_API TickRuleScope : GroupInstance
88  {
89  public:
90  /// Defines the instrument type for the tick rule.
92  {
93  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::TickRuleProductComplex);
94  }
95 
96  /// Trade Type
98  {
99  return getIntEnumFieldValue<TrdType>(*this, Tags::TrdType);
100  }
101 
102  private:
103  friend class TypedGroup<TickRuleScope>;
104 
105  TickRuleScope (const GroupInstance& groupInstance)
106  : GroupInstance (groupInstance)
107  {
108  }
109  };
110 
111  /// Tick rule scope definitions.
112  class TickRuleScopes : public TypedGroup<TickRuleScope>
113  {
114  private:
115  explicit
116  TickRuleScopes (const Group& group)
117  : TypedGroup<TickRuleScope> (group)
118  {
119  }
120 
121  friend class TickRule;
122  };
123 
124 
125  /// Tick rule.
126  class ONIXS_EUREX_EMDI_API TickRule : GroupInstance
127  {
128  public:
129  /// Table identifier, only for cash.
131  {
132  return getUInt32 (Tags::TickRuleID);
133  }
134 
135  /// Starting price range for specified tick increment (inclusive).
137  {
138  return getDecimal (Tags::StartTickPriceRange);
139  }
140 
141  /// Ending price range for the specified tick increment (noninclusive).
143  {
144  return getDecimal (Tags::EndTickPriceRange);
145  }
146 
147  /// Tick increment for stated price range. Specifies the valid price
148  /// increments at which instrument of the product can be quoted and
149  /// traded.
151  {
152  return getDecimal (Tags::TickIncrement);
153  }
154 
155  /// Tick rule scope definitions.
157  {
158  return TickRuleScopes ( getOptionalGroup (Tags::NoTickRuleScopes));
159  }
160 
161  private:
162  friend class TypedGroup<TickRule>;
163 
164  TickRule (const GroupInstance& groupInstance)
165  : GroupInstance (groupInstance)
166  {
167  }
168  };
169 
170  class TickRules : public TypedGroup<TickRule>
171  {
172  private:
173  explicit
174  TickRules (const Group& group)
175  : TypedGroup<TickRule> (group)
176  {
177  }
178 
179  friend class ProductSnapshot;
180  };
181 
182  /// Exposes list of available match algorithms.
183  struct ONIXS_EUREX_EMDI_API MatchAlgorithm
184  {
185  enum Enum
186  {
187  /// Used to identify absence of value.
188  Undefined = -1,
189 
190  ///
191  PriceTime = 0,
192 
193  ///
194  ProRata = 1,
195 
196  ///
197  TimeProRata = 2,
198  };
199  };
200 
201 
202  /// Exposes list of available match types.
203  struct ONIXS_EUREX_EMDI_API MatchType
204  {
205  enum Enum
206  {
207  /// Used to identify absence of value.
208  Undefined = -1,
209 
210  ///
211  AutoMatch = 0,
212 
213  ///
214  CallAuction = 2,
215  };
216  };
217 
218 
219  /// Exposes list of available market segment types.
220  struct ONIXS_EUREX_EMDI_API USApproval
221  {
222  enum Enum
223  {
224  /// Used to identify absence of value.
225  Undefined = -1,
226 
227  ///
228  NoApproval = 0,
229 
230  ///
231  CFTCApproved = 0,
232 
233  ///
234  SECApproved = 0,
235  };
236  };
237 
238  /// Exposes list of available market segment types.
239  struct ONIXS_EUREX_EMDI_API MarketSegmentType
240  {
241  enum Enum
242  {
243  /// Used to identify absence of value.
244  Undefined = -1,
245 
246  ///
247  Pool = 0,
248  };
249  };
250 
251 
252  /// Exposes list of available market segment subtypes.
253  struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
254  {
255  enum Enum
256  {
257  /// Used to identify absence of value.
258  Undefined = -1,
259 
260  ///
261  InterProductSpread = 0,
262 
263  ///
264  BTRFBucket = 1,
265 
266  ///
267  EBBBucket = 2,
268  };
269  };
270 
271  /// Exposes list of available Decay splits.
272  struct ONIXS_EUREX_EMDI_API DecaySplit
273  {
274  enum Enum
275  {
276  /// Used to identify absence of value.
277  Undefined = -1,
278 
279  ///
280  Month = 0,
281 
282  ///
283  Quarter = 1,
284 
285  ///
286  Season = 2,
287 
288  ///
289  Year = 3,
290  };
291  };
292 
293  /// Exposes list of available auction types.
294  struct ONIXS_EUREX_EMDI_API AuctionType
295  {
296  enum Enum
297  {
298  /// Used to identify absence of value.
299  Undefined = -1,
300 
301  ///
302  AnyAuction = 0,
303  };
304  };
305 
306  /// Exposes list of available closed book indicators.
307  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
308  {
309  enum Enum
310  {
311  /// Used to identify absence of value.
312  Undefined = -1,
313 
314  ///
315  No = 0,
316 
317  ///
318  Yes = 1,
319  };
320  };
321 
322  /// Exposes list of available market imbalance indicators.
323  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
324  {
325  enum Enum
326  {
327  /// Used to identify absence of value.
328  Undefined = -1,
329 
330  ///
331  No = 0,
332 
333  ///
334  Yes = 1,
335  };
336  };
337 
338  /// Exposes list of available market segment relationship types.
339  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
340  {
341  enum Enum
342  {
343  /// Used to identify absence of value.
344  Undefined = -1,
345 
346  ///
347  CashLegForVolatilityStrategies = 0,
348 
349  ///
350  TargetProductForDecayingProduct = 1,
351 
352  ///
353  BTRFBucket = 2,
354 
355  ///
356  EBBBucket = 3,
357  };
358  };
359 
360  /// Match rule.
361  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
362  {
363  public:
364  /// Defines the instrument type for the match rule.
366  {
367  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
368  }
369 
370  /// Defines the matching algorithm.
372  {
373  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
374  }
375 
376  /// Defines the matching type.
377  /// @note Absence means no distinction between continuous and auctions
379  {
380  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
381  }
382 
383  private:
384  friend class TypedGroup<MatchRule>;
385 
386  MatchRule (const GroupInstance& groupInstance)
387  : GroupInstance (groupInstance)
388  {
389  }
390  };
391 
392  class MatchRules : public TypedGroup<MatchRule>
393  {
394  private:
395  explicit
396  MatchRules (const Group& group)
397  : TypedGroup<MatchRule> (group)
398  {
399  }
400 
401  friend class ProductSnapshot;
402  };
403 
404  /// Quote size rule.
405  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
406  {
407  public:
408 
409  /// Minimum bid quantity (identical to minimum offer quantity).
410  bool minBidSize (Decimal& size) const
411  {
412  return get (Tags::MinBidSize).toNumber (size);
413  }
414 
415  /// Minimum offer quantity (identical to minimum bid quantity).
416  bool minOfferSize (Decimal& size) const
417  {
418  return get (Tags::MinOfferSize).toNumber (size);
419  }
420 
421  /// Indicates if product is in the state Fast Market.
422  bool fastMarketIndicator() const
423  {
424  UInt32 value;
425  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
426  }
427 
428  private:
429  friend class TypedGroup<QuoteSizeRule>;
430 
431  QuoteSizeRule (const GroupInstance& groupInstance)
432  : GroupInstance (groupInstance)
433  {
434  }
435  };
436 
437  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
438  {
439  private:
440  explicit
441  QuoteSizeRules (const Group& group)
442  : TypedGroup<QuoteSizeRule> (group)
443  {
444  }
445 
446  friend class ProductSnapshot;
447  };
448 
449  /// Flex rule.
450  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
451  {
452  public:
453 
454  /// Defines the strategy types available for user defined strategies.
456  {
457  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
458  }
459 
460  /// Defines if user defined strategies are allowed.
462  {
463  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
464  }
465 
466  private:
467  friend class TypedGroup<FlexRule>;
468 
469  FlexRule (const GroupInstance& groupInstance)
470  : GroupInstance (groupInstance)
471  {
472  }
473  };
474 
475  class FlexRules : public TypedGroup<FlexRule>
476  {
477  private:
478  explicit
479  FlexRules (const Group& group)
480  : TypedGroup<FlexRule> (group)
481  {
482  }
483 
484  friend class ProductSnapshot;
485  };
486 
487 
488  /// Auction type rule.
489  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
490  {
491  public:
492  /// Defines the type of auction.
494  {
495  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
496  }
497 
498  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
500  {
501  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
502  }
503 
504  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
505  /// order interruption phase a surplus (side and volume) at the indicative price
506  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
507  /// is displayed to the market.
509  {
510  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
511  }
512 
513  private:
515 
516  AuctionTypeRule (const GroupInstance& groupInstance)
517  : GroupInstance (groupInstance)
518  {
519  }
520  };
521 
522  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
523  {
524  private:
525  explicit
526  AuctionTypeRules (const Group& group)
528  {
529  }
530 
531  friend class ProductSnapshot;
532  };
533 
534  /// Feed
535  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
536  {
537  public:
538 
539  /// Feed type.
541  {
542  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
543  }
544 
545  /// Book type.
547  {
548  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
549  }
550 
551  /// Maximum number of price levels for the product.
552  bool marketDepth (UInt32& depth) const
553  {
554  return get (Tags::MarketDepth).toNumber (depth);
555  }
556 
557  /// Netting interval for low bandwidth feeds (0=no netting).
558  bool marketDepthTimeInterval (UInt32& interval) const
559  {
560  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
561  }
562 
563  /// Recovery interval (duration of one cycle).
564  bool mdRecoveryTimeInterval (UInt32& interval) const
565  {
566  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
567  }
568 
569  /// IP Address for Service A.
571  {
572  StringRef val;
573  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
574  }
575 
576  /// Port number for IP address Service A.
578  {
579  return getUInt32 (Tags::PrimaryServiceLocationSubID);
580  }
581 
582  /// IP Address for Service B.
584  {
585  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
586  }
587 
588  /// Port number for IP address Service B.
589  bool mdSecondaryFeedLineSubID (UInt32& subId) const
590  {
591  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
592  }
593 
594  private:
595  friend class TypedGroup<Feed>;
596 
597  Feed (const GroupInstance& groupInstance)
598  : GroupInstance (groupInstance)
599  {
600  }
601  };
602 
603  class Feeds : public TypedGroup<Feed>
604  {
605  private:
606  explicit
607  Feeds (const Group& group)
608  : TypedGroup<Feed> (group)
609  {
610  }
611 
612  friend class ProductSnapshot;
613  };
614 
615  /// Price range rule.
616  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
617  {
618  public:
619 
620  /// Table identifier, not unique within repeating group.
622  {
623  return getUInt32 (Tags::PriceRangeRuleID);
624  }
625 
626  ///
628  {
629  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
630  }
631 
632  /// Start of price range (inclusive).
634  {
635  return getDecimal (Tags::StartPriceRange);
636  }
637 
638  /// End of price range (non-inclusive).
640  {
641  return getDecimal (Tags::EndPriceRange);
642  }
643 
644  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
645  bool priceRangeValue (Decimal& value) const
646  {
647  return get (Tags::PriceRangeValue).toNumber (value);
648  }
649 
650  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
651  bool priceRangePercentage (Decimal& percentage) const
652  {
653  return get (Tags::PriceRangePercentage).toNumber (percentage);
654  }
655 
656  private:
657  friend class TypedGroup<PriceRangeRule>;
658 
659  PriceRangeRule (const GroupInstance& groupInstance)
660  : GroupInstance (groupInstance)
661  {
662  }
663  };
664 
665  class PriceRangeRules : public TypedGroup<PriceRangeRule>
666  {
667  private:
668  explicit
669  PriceRangeRules (const Group& group)
671  {
672  }
673 
674  friend class ProductSnapshot;
675  };
676 
677 
678  /// Instrument Scope.
679  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
680  {
681  public:
682 
683  /// Instrument scope operator.
685  {
686  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
687  }
688 
689  /// Type of security.
691  {
692  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
693  }
694 
695  /// Standard strategy type for complex instruments.
697  {
698  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
699  }
700 
701  private:
703 
704  InstrumentScope (const GroupInstance& groupInstance)
705  : GroupInstance (groupInstance)
706  {
707  }
708  };
709 
710  class InstrumentScopes : public TypedGroup<InstrumentScope>
711  {
712  private:
713  explicit
714  InstrumentScopes (const Group& group)
716  {
717  }
718 
719  friend class ProductSnapshot;
720  };
721 
722 
723  /// Related Market Segments.
724  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
725  {
726  public:
727 
728  /// Market segment identifier.
730  {
731  return getUInt32 (Tags::RelatedMarketSegmentID);
732  }
733 
734  /// Defines the type of the relationship..
736  {
737  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
738  }
739 
740  private:
742 
743  RelatedMarketSegment (const GroupInstance& groupInstance)
744  : GroupInstance (groupInstance)
745  {
746  }
747  };
748 
749  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
750  {
751  private:
752  explicit
753  RelatedMarketSegments (const Group& group)
755  {
756  }
757 
758  friend class ProductSnapshot;
759  };
760 
761  /// Product snapshot.
762  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
763  {
764  public:
765 
766  /// Market Identifier Code as specified in ISO 10383.
768  {
769  return getStringRef (Tags::MarketID);
770  }
771 
772  /// Product identifier.
774  {
775  return getUInt32 (Tags::MarketSegmentID);
776  }
777 
778  /// Current business date
780  {
781  return getUInt32 (Tags::EffectiveBusinessDate);
782  }
783 
784  /// Next business date
786  {
787  return getUInt32 (Tags::NextEffectiveBusinessDate);
788  }
789 
790  /// Product name.
792  {
793  return getStringRef (Tags::MarketSegment);
794  }
795 
796  /// Currency as published in ISO 4217.
798  {
799  return getStringRef (Tags::Currency);
800  }
801 
802  /// Defines the TES security status.
804  {
805  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
806  }
807 
808  /// Partition of the product.
810  {
811  return getUInt32 (Tags::PartitionID);
812  }
813 
814  /// Contains the default and maximum duration of negotiation event in seconds.
815  bool negotiationDuration(UInt32& value) const
816  {
817  return get(Tags::NegotiationDuration).toNumber(value);
818  }
819 
820  /// Product Description.
821  bool marketSegmentDesc (StringRef& desc) const
822  {
823  return get (Tags::MarketSegmentDesc).toStringRef (desc);
824  }
825 
826  /// Product ISIN.
827  bool marketSegmentSymbol (StringRef& symbol) const
828  {
829  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
830  }
831 
832  /// Standard Eurex product types.
833  bool parentMktSegmID (StringRef& id) const
834  {
835  return get (Tags::ParentMktSegmID).toStringRef (id);
836  }
837 
838  /// Market Segmen type.
840  {
841  return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
842  }
843 
844  /// Market Segmen type.
846  {
847  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
848  }
849 
850  /// Market Segment subtype.
852  {
853  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
854  }
855 
856  ///
858  {
859  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
860  }
861 
862  /// Defines the max expiry time in seconds describing when the RFQ session will be
863  /// automatically terminated.
864  bool maxOffsetRFQExpireTime(UInt32& value) const
865  {
866  return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
867  }
868 
869  /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
870  bool offsetSTPEffectiveTime(UInt32& value) const
871  {
872  return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
873  }
874 
875  /// Market Identifier Code of the underlying as specified in ISO 10383.
877  {
878  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
879  }
880 
881  /// Underlying security symbol
882  bool underlyingSymbol (StringRef& value) const
883  {
884  return get (Tags::UnderlyingSymbol).toStringRef (value);
885  }
886 
887  /// ISIN code of the underlying.
888  bool underlyingSecurityId (StringRef& value) const
889  {
890  return get (Tags::UnderlyingSecurityID).toStringRef (value);
891  }
892 
893  /// Underlying Security ID Source.
895  {
896  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
897  }
898 
899  /// Closing price of the underlying on the previous day.
900  bool underlyingPrevClosePx (Decimal& price) const
901  {
902  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
903  }
904 
905  /// Instrument Scopes.
907  {
908  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
909  }
910 
911  /// Related Market Segments.
913  {
914  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
915  }
916 
917  /// Tick rules.
918  /// The group is absent for buckets, when marketSegmentSubType() is equel to
919  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
921  {
922  checkSequencePresence("tickRules");
923 
924  return TickRules (getGroup(Tags::NoTickRules) );
925  }
926 
927  /// Price range rules.
928  /// The group is absent for buckets, when marketSegmentSubType() is equel to
929  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
931  {
932  return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
933  }
934 
935  /// Defines if one sided quotes are allowed
937  {
938  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
939  }
940 
941  /// Defines if one sided quotes are allowed
943  {
944  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
945  }
946 
947  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
948  /// has to be extended to obtain the valid price range during Fast Market
949  bool fastMarketPercentage (Decimal& value) const
950  {
951  return get (Tags::FastMarketPercentage).toNumber (value);
952  }
953 
954  /// Specifies if Market Orders will be checked against the available bid/ask price on the opposing side in specifc scenarios.
955  bool checkMarketOrder() const
956  {
957  UInt32 value;
958  return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
959  }
960 
961  /// Quote size rules.
963  {
964  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
965  }
966 
967  /// Flex rules.
969  {
970  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
971  }
972 
973  /// Minimum Tradable Unit in derivatives markets.
974  bool roundLot(Decimal& value) const
975  {
976  return get(Tags::RoundLot).toNumber(value);
977  }
978 
979  /// Match rules.
981  {
982  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
983  }
984 
985  /// Match rules.
986  /// The group is absent for buckets, when marketSegmentSubType() is equel to
987  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
989  {
990  checkSequencePresence("matchRules");
991  return MatchRules (getGroup(Tags::NoMatchRules) );
992  }
993 
994  /// Feeds
995  /// The group is absent for buckets, when marketSegmentSubType() is equel to
996  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
997  Feeds feeds() const
998  {
999  checkSequencePresence("feeds");
1000  return Feeds (getGroup(Tags::NoMDFeedTypes) );
1001  }
1002 
1003  private:
1004  friend class ProductSnapshotWrapper;
1005 
1006  ProductSnapshot (const void* impl)
1007  : Message (impl)
1008  {
1009  }
1010 
1011  void checkSequencePresence(const char* seqName) const
1012  {
1013  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket || marketSegmentSubType() == MarketSegmentSubType::EBBBucket)
1014  {
1015  const std::string enhancedName =
1016  std::string("Rdi ProductSnapshot::") + seqName;
1017 
1018  throw OperationException(
1019  enhancedName.c_str(), "The sequence is absent for BTRFBucket and EBBBucket subtypes");
1020  }
1021  }
1022  };
1023  }
1024  }
1025 }
StringRef marketId() const
Market Identifier Code as specified in ISO 10383.
const Tag EffectiveBusinessDate
Definition: Tags.h:197
SecurityType::Enum securityType() const
Type of security.
InstrumentScopeOperator::Enum instrumentScopeOperator() const
Instrument scope operator.
const Tag QuoteSideModelType
Definition: Tags.h:243
MatchAlgorithm::Enum matchAlgorithm() const
Defines the matching algorithm.
const Tag MatchRuleProductComplex
Definition: Tags.h:140
StringRef mdPrimaryFeedLineID() const
IP Address for Service A.
const Tag UnderlyingSecurityID
Definition: Tags.h:157
const Tag UnderlyingPrevClosePx
Definition: Tags.h:151
Exposes list of available market segment types.
InstrumentType::Enum priceRangeProductComplex() const
const Tag NegotiationDuration
Definition: Tags.h:275
bool underlyingSymbol(StringRef &value) const
Underlying security symbol.
UInt32 PartitionId
Alias for Partition ID type.
Definition: Defines.h:48
const Tag MarketSegmentSymbol
Definition: Tags.h:118
const Tag MarketSegmentSubType
Definition: Tags.h:200
Tick rule scope definitions.
bool parentMktSegmID(StringRef &id) const
Standard Eurex product types.
Exposes list of available market segment subtypes.
const Tag StartTickPriceRange
Definition: Tags.h:103
Decimal endTickPriceRange() const
Ending price range for the specified tick increment (noninclusive).
const Tag MaxOffsetRFQExpireTime
Definition: Tags.h:277
const Tag MarketSegmentStatus
Definition: Tags.h:126
const Tag ClosedBookIndicator
Definition: Tags.h:207
Exposes list of available Quote side indicators.
const Tag PrimaryServiceLocationID
Definition: Tags.h:122
const Tag SecondaryServiceLocationSubID
Definition: Tags.h:125
QuoteSideModelType::Enum quoteSideModelType() const
Defines if one sided quotes are allowed.
const Tag SecondaryServiceLocationID
Definition: Tags.h:124
FeedType::Enum mdFeedType() const
Feed type.
bool fastMarketIndicator() const
Indicates if product is in the state Fast Market.
Exposes list of available Decay splits.
FlexRules flexRules() const
Flex rules.
bool negotiationDuration(UInt32 &value) const
Contains the default and maximum duration of negotiation event in seconds.
MarketSegmentId marketSegmentId() const
Product identifier.
TickRuleScopes tickRuleScopes() const
Tick rule scope definitions.
const Tag MarketDepthTimeInterval
Definition: Tags.h:152
MarketSegmentRelationship::Enum marketSegmentRelationship() const
Defines the type of the relationship..
bool minOfferSize(Decimal &size) const
Minimum offer quantity (identical to minimum bid quantity).
UInt32 tickRuleId() const
Table identifier, only for cash.
bool offsetSTPEffectiveTime(UInt32 &value) const
Defines the waiting period of the final STP deal inside Eurex EnLight in seconds. ...
Defines all the months in the year.
Definition: Timestamp.h:35
MarketSegmentSubType::Enum marketSegmentSubType() const
Market Segment subtype.
AuctionType::Enum auctionType() const
Defines the type of auction.
Decimal startPriceRange() const
Start of price range (inclusive).
MarketSegmentStatus::Enum marketSegmentStatus() const
Defines the TES security status.
const Tag FlexProductEligibilityIndicator
Definition: Tags.h:108
const Tag QuoteSideIndicator
Definition: Tags.h:202
const Tag InstrumentScopeSecurityType
Definition: Tags.h:181
const Tag MarketImbalanceIndicator
Definition: Tags.h:208
Exposes list of available quote side model types.
const Tag NextEffectiveBusinessDate
Definition: Tags.h:198
unsigned int UInt32
Definition: Numeric.h:41
Exposes list of available market segment types.
bool underlyingSecurityExchange(StringRef &value) const
Market Identifier Code of the underlying as specified in ISO 10383.
Exposes list of available market segment relationship types.
Definition: Defines.h:30
Decimal type for better precision.
Definition: Numeric.h:63
Exposes list of available match types.
MarketSegmentType::Enum marketSegmentType() const
Market Segmen type.
bool instrumentScopeSecuritySubType(UInt32 &value) const
Standard strategy type for complex instruments.
bool checkMarketOrder() const
Specifies if Market Orders will be checked against the available bid/ask price on the opposing side i...
const Tag TickRuleProductComplex
Definition: Tags.h:139
bool underlyingSecurityId(StringRef &value) const
ISIN code of the underlying.
const Tag NoRelatedMarketSegments
Definition: Tags.h:176
Exposes list of available market imbalance indicators.
bool mdRecoveryTimeInterval(UInt32 &interval) const
Recovery interval (duration of one cycle).
Exposes list of available match algorithms.
UInt32 priceRangeRuleID() const
Table identifier, not unique within repeating group.
Decimal startTickPriceRange() const
Starting price range for specified tick increment (inclusive).
bool priceRangeValue(Decimal &value) const
Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is ab...
bool marketDepth(UInt32 &depth) const
Maximum number of price levels for the product.
UInt32 relatedMarketSegmentID() const
Market segment identifier.
bool priceRangePercentage(Decimal &percentage) const
Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absen...
const Tag OffsetSTPEffectiveTime
Definition: Tags.h:278
const Tag MDRecoveryTimeInterval
Definition: Tags.h:153
const Tag PrimaryServiceLocationSubID
Definition: Tags.h:123
RelatedMarketSegments relatedMarketSegments() const
Related Market Segments.
InstrumentType::Enum tickRuleProductComplex() const
Defines the instrument type for the tick rule.
bool minBidSize(Decimal &size) const
Minimum bid quantity (identical to minimum offer quantity).
StringRef currency() const
Currency as published in ISO 4217.
const Tag PriceRangePercentage
Definition: Tags.h:131
const Tag UnderlyingSecurityIDSource
Definition: Tags.h:155
Exposes list of available closed book indicators.
QuoteSideIndicator::Enum quoteSideIndicator() const
Defines if one sided quotes are allowed.
USApproval::Enum usApproval() const
Market Segmen type.
const Tag FastMarketPercentage
Definition: Tags.h:203
bool roundLot(Decimal &value) const
Minimum Tradable Unit in derivatives markets.
const Tag InstrumentScopeOperator
Definition: Tags.h:180
bool underlyingPrevClosePx(Decimal &price) const
Closing price of the underlying on the previous day.
UInt32 mdPrimaryFeedLineSubID() const
Port number for IP address Service A.
StringRef marketSegment() const
Product name.
MarketImbalanceIndicator::Enum marketImbalanceIndicator() const
const Tag NoFlexProductEligibilities
Definition: Tags.h:145
bool fastMarketPercentage(Decimal &value) const
bool mdSecondaryFeedLineSubID(UInt32 &subId) const
Port number for IP address Service B.
bool marketSegmentSymbol(StringRef &symbol) const
Product ISIN.
const Tag MarketSegmentRelationship
Definition: Tags.h:178
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
Exposes list of available auction types.
const Tag PriceRangeProductComplex
Definition: Tags.h:132
UInt32 nextEffectiveBusinessDate() const
Next business date.
const Tag RelatedMarketSegmentID
Definition: Tags.h:177
Decimal endPriceRange() const
End of price range (non-inclusive).
const Tag InstrumentScopeSecuritySubType
Definition: Tags.h:182
const Tag FastMarketIndicator
Definition: Tags.h:143
TrdType::Enum trdType() const
Trade Type.
InstrumentType::Enum matchRuleProductComplex() const
Defines the instrument type for the match rule.
AuctionTypeRules auctionTypeRules() const
Match rules.
bool marketDepthTimeInterval(UInt32 &interval) const
Netting interval for low bandwidth feeds (0=no netting).
InstrumentScopes instrumentScopes() const
Instrument Scopes.
ClosedBookIndicator::Enum closedBookIndicator() const
Indicates whether the order book is closed during auction trading. "N" reserved for future releases...
UInt32 effectiveBusinessDate() const
Current business date.
bool maxOffsetRFQExpireTime(UInt32 &value) const
QuoteSizeRules quoteSizeRules() const
Quote size rules.
bool mdSecondaryFeedLineID(StringRef &id) const
IP Address for Service B.
const Tag NoInstrumentScopes
Definition: Tags.h:179
Exposes list of available feed types.
InstrumentType::Enum flexProductEligibilityComplex() const
Defines the strategy types available for user defined strategies.
BookType::Enum mdBookType() const
Book type.
bool underlyingSecurityIdSource(StringRef &value) const
Underlying Security ID Source.
PartitionId partitionId() const
Partition of the product.
const Tag FlexProductEligibilityComplex
Definition: Tags.h:146
bool marketSegmentDesc(StringRef &desc) const
Product Description.
const Tag NoAuctionTypeRules
Definition: Tags.h:204
bool flexProductEligibilityIndicator() const
Defines if user defined strategies are allowed.
const Tag UnderlyingSecurityExchange
Definition: Tags.h:156
MatchType::Enum matchType() const