OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  8.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 
268  /// Exposes list of available Decay splits.
269  struct ONIXS_EUREX_EMDI_API DecaySplit
270  {
271  enum Enum
272  {
273  /// Used to identify absence of value.
274  Undefined = -1,
275 
276  ///
277  Month = 0,
278 
279  ///
280  Quarter = 1,
281 
282  ///
283  Season = 2,
284 
285  ///
286  Year = 3,
287  };
288  };
289 
290  /// Exposes list of available auction types.
291  struct ONIXS_EUREX_EMDI_API AuctionType
292  {
293  enum Enum
294  {
295  /// Used to identify absence of value.
296  Undefined = -1,
297 
298  ///
299  AnyAuction = 0,
300  };
301  };
302 
303  /// Exposes list of available closed book indicators.
304  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
305  {
306  enum Enum
307  {
308  /// Used to identify absence of value.
309  Undefined = -1,
310 
311  ///
312  No = 0,
313 
314  ///
315  Yes = 1,
316  };
317  };
318 
319  /// Exposes list of available market imbalance indicators.
320  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
321  {
322  enum Enum
323  {
324  /// Used to identify absence of value.
325  Undefined = -1,
326 
327  ///
328  No = 0,
329 
330  ///
331  Yes = 1,
332  };
333  };
334 
335  /// Exposes list of available market segment relationship types.
336  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
337  {
338  enum Enum
339  {
340  /// Used to identify absence of value.
341  Undefined = -1,
342 
343  ///
344  CashLegForVolatilityStrategies = 0,
345 
346  ///
347  TargetProductForDecayingProduct = 1,
348 
349  ///
350  BTRFBucket = 2,
351  };
352  };
353 
354  /// Match rule.
355  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
356  {
357  public:
358  /// Defines the instrument type for the match rule.
360  {
361  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
362  }
363 
364  /// Defines the matching algorithm.
366  {
367  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
368  }
369 
370  /// Defines the matching type.
371  /// @note Absence means no distinction between continuous and auctions
373  {
374  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
375  }
376 
377  private:
378  friend class TypedGroup<MatchRule>;
379 
380  MatchRule (const GroupInstance& groupInstance)
381  : GroupInstance (groupInstance)
382  {
383  }
384  };
385 
386  class MatchRules : public TypedGroup<MatchRule>
387  {
388  private:
389  explicit
390  MatchRules (const Group& group)
391  : TypedGroup<MatchRule> (group)
392  {
393  }
394 
395  friend class ProductSnapshot;
396  };
397 
398  /// Quote size rule.
399  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
400  {
401  public:
402 
403  /// Minimum bid quantity (identical to minimum offer quantity).
404  bool minBidSize (Decimal& size) const
405  {
406  return get (Tags::MinBidSize).toNumber (size);
407  }
408 
409  /// Minimum offer quantity (identical to minimum bid quantity).
410  bool minOfferSize (Decimal& size) const
411  {
412  return get (Tags::MinOfferSize).toNumber (size);
413  }
414 
415  /// Indicates if product is in the state Fast Market.
416  bool fastMarketIndicator() const
417  {
418  UInt32 value;
419  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
420  }
421 
422  private:
423  friend class TypedGroup<QuoteSizeRule>;
424 
425  QuoteSizeRule (const GroupInstance& groupInstance)
426  : GroupInstance (groupInstance)
427  {
428  }
429  };
430 
431  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
432  {
433  private:
434  explicit
435  QuoteSizeRules (const Group& group)
436  : TypedGroup<QuoteSizeRule> (group)
437  {
438  }
439 
440  friend class ProductSnapshot;
441  };
442 
443  /// Flex rule.
444  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
445  {
446  public:
447 
448  /// Defines the strategy types available for user defined strategies.
450  {
451  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
452  }
453 
454  /// Defines if user defined strategies are allowed.
456  {
457  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
458  }
459 
460  private:
461  friend class TypedGroup<FlexRule>;
462 
463  FlexRule (const GroupInstance& groupInstance)
464  : GroupInstance (groupInstance)
465  {
466  }
467  };
468 
469  class FlexRules : public TypedGroup<FlexRule>
470  {
471  private:
472  explicit
473  FlexRules (const Group& group)
474  : TypedGroup<FlexRule> (group)
475  {
476  }
477 
478  friend class ProductSnapshot;
479  };
480 
481 
482  /// Auction type rule.
483  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
484  {
485  public:
486  /// Defines the type of auction.
488  {
489  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
490  }
491 
492  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
494  {
495  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
496  }
497 
498  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
499  /// order interruption phase a surplus (side and volume) at the indicative price
500  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
501  /// is displayed to the market.
503  {
504  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
505  }
506 
507  private:
509 
510  AuctionTypeRule (const GroupInstance& groupInstance)
511  : GroupInstance (groupInstance)
512  {
513  }
514  };
515 
516  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
517  {
518  private:
519  explicit
520  AuctionTypeRules (const Group& group)
522  {
523  }
524 
525  friend class ProductSnapshot;
526  };
527 
528  /// Feed
529  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
530  {
531  public:
532 
533  /// Feed type.
535  {
536  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
537  }
538 
539  /// Book type.
541  {
542  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
543  }
544 
545  /// Maximum number of price levels for the product.
546  bool marketDepth (UInt32& depth) const
547  {
548  return get (Tags::MarketDepth).toNumber (depth);
549  }
550 
551  /// Netting interval for low bandwidth feeds (0=no netting).
552  bool marketDepthTimeInterval (UInt32& interval) const
553  {
554  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
555  }
556 
557  /// Recovery interval (duration of one cycle).
558  bool mdRecoveryTimeInterval (UInt32& interval) const
559  {
560  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
561  }
562 
563  /// IP Address for Service A.
565  {
566  StringRef val;
567  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
568  }
569 
570  /// Port number for IP address Service A.
572  {
573  return getUInt32 (Tags::PrimaryServiceLocationSubID);
574  }
575 
576  /// IP Address for Service B.
578  {
579  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
580  }
581 
582  /// Port number for IP address Service B.
583  bool mdSecondaryFeedLineSubID (UInt32& subId) const
584  {
585  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
586  }
587 
588  private:
589  friend class TypedGroup<Feed>;
590 
591  Feed (const GroupInstance& groupInstance)
592  : GroupInstance (groupInstance)
593  {
594  }
595  };
596 
597  class Feeds : public TypedGroup<Feed>
598  {
599  private:
600  explicit
601  Feeds (const Group& group)
602  : TypedGroup<Feed> (group)
603  {
604  }
605 
606  friend class ProductSnapshot;
607  };
608 
609  /// Price range rule.
610  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
611  {
612  public:
613 
614  /// Table identifier, not unique within repeating group.
616  {
617  return getUInt32 (Tags::PriceRangeRuleID);
618  }
619 
620  ///
622  {
623  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
624  }
625 
626  /// Start of price range (inclusive).
628  {
629  return getDecimal (Tags::StartPriceRange);
630  }
631 
632  /// End of price range (non-inclusive).
634  {
635  return getDecimal (Tags::EndPriceRange);
636  }
637 
638  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
639  bool priceRangeValue (Decimal& value) const
640  {
641  return get (Tags::PriceRangeValue).toNumber (value);
642  }
643 
644  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
645  bool priceRangePercentage (Decimal& percentage) const
646  {
647  return get (Tags::PriceRangePercentage).toNumber (percentage);
648  }
649 
650  private:
651  friend class TypedGroup<PriceRangeRule>;
652 
653  PriceRangeRule (const GroupInstance& groupInstance)
654  : GroupInstance (groupInstance)
655  {
656  }
657  };
658 
659  class PriceRangeRules : public TypedGroup<PriceRangeRule>
660  {
661  private:
662  explicit
663  PriceRangeRules (const Group& group)
665  {
666  }
667 
668  friend class ProductSnapshot;
669  };
670 
671 
672  /// Instrument Scope.
673  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
674  {
675  public:
676 
677  /// Instrument scope operator.
679  {
680  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
681  }
682 
683  /// Type of security.
685  {
686  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
687  }
688 
689  /// Standard strategy type for complex instruments.
691  {
692  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
693  }
694 
695  private:
697 
698  InstrumentScope (const GroupInstance& groupInstance)
699  : GroupInstance (groupInstance)
700  {
701  }
702  };
703 
704  class InstrumentScopes : public TypedGroup<InstrumentScope>
705  {
706  private:
707  explicit
708  InstrumentScopes (const Group& group)
710  {
711  }
712 
713  friend class ProductSnapshot;
714  };
715 
716 
717  /// Related Market Segments.
718  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
719  {
720  public:
721 
722  /// Market segment identifier.
724  {
725  return getUInt32 (Tags::RelatedMarketSegmentID);
726  }
727 
728  /// Defines the type of the relationship..
730  {
731  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
732  }
733 
734  private:
736 
737  RelatedMarketSegment (const GroupInstance& groupInstance)
738  : GroupInstance (groupInstance)
739  {
740  }
741  };
742 
743  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
744  {
745  private:
746  explicit
747  RelatedMarketSegments (const Group& group)
749  {
750  }
751 
752  friend class ProductSnapshot;
753  };
754 
755  /// Product snapshot.
756  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
757  {
758  public:
759 
760  /// Market Identifier Code as specified in ISO 10383.
762  {
763  return getStringRef (Tags::MarketID);
764  }
765 
766  /// Product identifier.
768  {
769  return getUInt32 (Tags::MarketSegmentID);
770  }
771 
772  /// Current business date
774  {
775  return getUInt32 (Tags::EffectiveBusinessDate);
776  }
777 
778  /// Next business date
780  {
781  return getUInt32 (Tags::NextEffectiveBusinessDate);
782  }
783 
784  /// Product name.
786  {
787  return getStringRef (Tags::MarketSegment);
788  }
789 
790  /// Currency as published in ISO 4217.
792  {
793  return getStringRef (Tags::Currency);
794  }
795 
796  /// Defines the TES security status.
798  {
799  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
800  }
801 
802  /// Partition of the product.
804  {
805  return getUInt32 (Tags::PartitionID);
806  }
807 
808  /// Contains the default and maximum duration of negotiation event in seconds.
809  bool negotiationDuration(UInt32& value) const
810  {
811  return get(Tags::NegotiationDuration).toNumber(value);
812  }
813 
814  /// Product Description.
815  bool marketSegmentDesc (StringRef& desc) const
816  {
817  return get (Tags::MarketSegmentDesc).toStringRef (desc);
818  }
819 
820  /// Product ISIN.
821  bool marketSegmentSymbol (StringRef& symbol) const
822  {
823  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
824  }
825 
826  /// Standard Eurex product types.
827  bool parentMktSegmID (StringRef& id) const
828  {
829  return get (Tags::ParentMktSegmID).toStringRef (id);
830  }
831 
832  /// Market Segmen type.
834  {
835  return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
836  }
837 
838  /// Market Segmen type.
840  {
841  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
842  }
843 
844  /// Market Segment subtype.
846  {
847  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
848  }
849 
850  ///
852  {
853  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
854  }
855 
856  /// Defines the max expiry time in seconds describing when the RFQ session will be
857  /// automatically terminated.
858  bool maxOffsetRFQExpireTime(UInt32& value) const
859  {
860  return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
861  }
862 
863  /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
864  bool offsetSTPEffectiveTime(UInt32& value) const
865  {
866  return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
867  }
868 
869  /// Market Identifier Code of the underlying as specified in ISO 10383.
871  {
872  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
873  }
874 
875  /// Underlying security symbol
876  bool underlyingSymbol (StringRef& value) const
877  {
878  return get (Tags::UnderlyingSymbol).toStringRef (value);
879  }
880 
881  /// ISIN code of the underlying.
882  bool underlyingSecurityId (StringRef& value) const
883  {
884  return get (Tags::UnderlyingSecurityID).toStringRef (value);
885  }
886 
887  /// Underlying Security ID Source.
889  {
890  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
891  }
892 
893  /// Closing price of the underlying on the previous day.
894  bool underlyingPrevClosePx (Decimal& price) const
895  {
896  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
897  }
898 
899  /// Instrument Scopes.
901  {
902  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
903  }
904 
905  /// Related Market Segments.
907  {
908  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
909  }
910 
911  /// Tick rules.
912  /// The group is absent for buckets, when marketSegmentSubType() is equel to
913  /// MarketSegmentSubType::BTRFBucket
915  {
916  checkSequencePresence("tickRules");
917 
918  return TickRules (getGroup(Tags::NoTickRules) );
919  }
920 
921  /// Price range rules.
922  /// The group is absent for buckets, when marketSegmentSubType() is equel to
923  /// MarketSegmentSubType::BTRFBucket
925  {
926  return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
927  }
928 
929  /// Defines if one sided quotes are allowed
931  {
932  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
933  }
934 
935  /// Defines if one sided quotes are allowed
937  {
938  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
939  }
940 
941  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
942  /// has to be extended to obtain the valid price range during Fast Market
943  bool fastMarketPercentage (Decimal& value) const
944  {
945  return get (Tags::FastMarketPercentage).toNumber (value);
946  }
947 
948  /// Quote size rules.
950  {
951  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
952  }
953 
954  /// Flex rules.
956  {
957  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
958  }
959 
960  /// Match rules.
962  {
963  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
964  }
965 
966  /// Match rules.
967  /// The group is absent for buckets, when marketSegmentSubType() is equel to
968  /// MarketSegmentSubType::BTRFBucket
970  {
971  checkSequencePresence("matchRules");
972  return MatchRules (getGroup(Tags::NoMatchRules) );
973  }
974 
975  /// Feeds
976  /// The group is absent for buckets, when marketSegmentSubType() is equel to
977  /// MarketSegmentSubType::BTRFBucket
978  Feeds feeds() const
979  {
980  checkSequencePresence("feeds");
981  return Feeds (getGroup(Tags::NoMDFeedTypes) );
982  }
983 
984  private:
986 
987  ProductSnapshot (const void* impl)
988  : Message (impl)
989  {
990  }
991 
992  void checkSequencePresence(const char* seqName) const
993  {
994  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket)
995  {
996  const std::string enhancedName =
997  std::string("Rdi ProductSnapshot::") + seqName;
998 
999  throw OperationException(
1000  enhancedName.c_str(), "The sequence is absent for BTRFBucket subtype");
1001  }
1002  }
1003  };
1004  }
1005  }
1006 }
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:31
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.
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
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