OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  18.2.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  /// Cross Match Instruction
88  struct ONIXS_EUREX_EMDI_API CrossMatchInstruction
89  {
90  enum Enum
91  {
92  /// Used to identify absence of value.
93  Undefined = -1,
94 
95  ///
96  CancelAggressive = 0,
97 
98  ///
100 
101  ///
103  };
104  };
105 
106  class ONIXS_EUREX_EMDI_API TickRuleScope : GroupInstance
107  {
108  public:
109  /// Defines the instrument type for the tick rule.
111  {
112  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::TickRuleProductComplex);
113  }
114 
115  /// Trade Type
117  {
118  return getIntEnumFieldValue<TrdType>(*this, Tags::TrdType);
119  }
120 
121  private:
122  friend class TypedGroup<TickRuleScope>;
123 
124  TickRuleScope (const GroupInstance& groupInstance)
125  : GroupInstance (groupInstance)
126  {
127  }
128  };
129 
130  /// Tick rule scope definitions.
131  class TickRuleScopes : public TypedGroup<TickRuleScope>
132  {
133  private:
134  explicit
135  TickRuleScopes (const Group& group)
136  : TypedGroup<TickRuleScope> (group)
137  {
138  }
139 
140  friend class TickRule;
141  };
142 
143 
144  /// Tick rule.
145  class ONIXS_EUREX_EMDI_API TickRule : GroupInstance
146  {
147  public:
148  /// Table identifier, only for cash.
150  {
151  return getUInt32 (Tags::TickRuleID);
152  }
153 
154  /// Starting price range for specified tick increment (inclusive).
156  {
157  return getDecimal (Tags::StartTickPriceRange);
158  }
159 
160  /// Ending price range for the specified tick increment (noninclusive).
162  {
163  return getDecimal (Tags::EndTickPriceRange);
164  }
165 
166  /// Tick increment for stated price range. Specifies the valid price
167  /// increments at which instrument of the product can be quoted and
168  /// traded.
170  {
171  return getDecimal (Tags::TickIncrement);
172  }
173 
174  /// Tick rule scope definitions.
176  {
177  return TickRuleScopes ( getOptionalGroup (Tags::NoTickRuleScopes));
178  }
179 
180  private:
181  friend class TypedGroup<TickRule>;
182 
183  TickRule (const GroupInstance& groupInstance)
184  : GroupInstance (groupInstance)
185  {
186  }
187  };
188 
189  class TickRules : public TypedGroup<TickRule>
190  {
191  private:
192  explicit
193  TickRules (const Group& group)
194  : TypedGroup<TickRule> (group)
195  {
196  }
197 
198  friend class ProductSnapshot;
199  };
200 
201  /// Exposes list of available match algorithms.
202  struct ONIXS_EUREX_EMDI_API MatchAlgorithm
203  {
204  enum Enum
205  {
206  /// Used to identify absence of value.
207  Undefined = -1,
208 
209  ///
210  PriceTime = 0,
211 
212  ///
213  ProRata = 1,
214 
215  ///
216  TimeProRata = 2,
217  };
218  };
219 
220 
221  /// Exposes list of available match types.
222  struct ONIXS_EUREX_EMDI_API MatchType
223  {
224  enum Enum
225  {
226  /// Used to identify absence of value.
227  Undefined = -1,
228 
229  ///
230  AutoMatch = 0,
231 
232  ///
233  CallAuction = 1,
234  };
235  };
236 
237 
238  /// Exposes list of available market segment types.
239  struct ONIXS_EUREX_EMDI_API USApproval
240  {
241  enum Enum
242  {
243  /// Used to identify absence of value.
244  Undefined = -1,
245 
246  ///
247  NoApproval = 0,
248 
249  ///
250  CFTCApproved = 1,
251 
252  ///
253  SECApproved = 2,
254  };
255  };
256 
257  /// Exposes list of available market segment types.
258  struct ONIXS_EUREX_EMDI_API MarketSegmentType
259  {
260  enum Enum
261  {
262  /// Used to identify absence of value.
263  Undefined = -1,
264 
265  ///
266  Pool = 0,
267  };
268  };
269 
270 
271  /// Exposes list of available market segment subtypes.
272  struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
273  {
274  enum Enum
275  {
276  /// Used to identify absence of value.
277  Undefined = -1,
278 
279  ///
280  InterProductSpread = 0,
281 
282  ///
283  BTRFBucket = 1,
284 
285  ///
286  EBBBucket = 2,
287 
288  ///
289  CommodityGroup = 3,
290  };
291  };
292 
293  /// Exposes list of available Decay splits.
294  struct ONIXS_EUREX_EMDI_API DecaySplit
295  {
296  enum Enum
297  {
298  /// Used to identify absence of value.
299  Undefined = -1,
300 
301  ///
302  Quarter = 0,
303 
304  ///
305  Season = 1,
306 
307  ///
308  Year = 2,
309  };
310  };
311 
312  /// Exposes list of available auction types.
313  struct ONIXS_EUREX_EMDI_API AuctionType
314  {
315  enum Enum
316  {
317  /// Used to identify absence of value.
318  Undefined = -1,
319 
320  ///
321  AnyAuction = 0,
322  };
323  };
324 
325  /// Exposes list of available closed book indicators.
326  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
327  {
328  enum Enum
329  {
330  /// Used to identify absence of value.
331  Undefined = -1,
332 
333  ///
334  No = 0,
335 
336  ///
337  Yes = 1,
338  };
339  };
340 
341  /// Exposes list of available market imbalance indicators.
342  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
343  {
344  enum Enum
345  {
346  /// Used to identify absence of value.
347  Undefined = -1,
348 
349  ///
350  No = 0,
351 
352  ///
353  Yes = 1,
354  };
355  };
356 
357  ///
358  struct ONIXS_EUREX_EMDI_API DisableOnBookTrading
359  {
360  enum Enum
361  {
362  /// Used to identify absence of value.
363  Undefined = -1,
364 
365  ///
366  No = 0,
367 
368  ///
369  Yes = 1,
370  };
371  };
372 
373  /// Exposes list of available market segment relationship types.
374  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
375  {
376  enum Enum
377  {
378  /// Used to identify absence of value.
379  Undefined = -1,
380 
381  ///
382  CashLegForVolatilityStrategies = 0,
383 
384  ///
385  TargetProductForDecayingProduct = 1,
386 
387  ///
388  BTRFBucket = 2,
389 
390  ///
391  EBBBucket = 3,
392 
393  ///
394  CommodityGroup = 4,
395  };
396  };
397 
398  struct ONIXS_EUREX_EMDI_API AllowOneProductStrip
399  {
400  enum Enum
401  {
402  /// Used to identify absence of value.
403  Undefined = -1,
404 
405  ///
406  OneProductStripNotAllowed = 0,
407 
408  ///
409  OneProductStripNot = 1,
410  };
411  };
412 
413  /// Match rule.
414  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
415  {
416  public:
417  /// Defines the instrument type for the match rule.
419  {
420  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
421  }
422 
423  /// Defines the matching algorithm.
425  {
426  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
427  }
428 
429  /// Defines the matching type.
430  /// @note Absence means no distinction between continuous and auctions
432  {
433  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
434  }
435 
436  private:
437  friend class TypedGroup<MatchRule>;
438 
439  MatchRule (const GroupInstance& groupInstance)
440  : GroupInstance (groupInstance)
441  {
442  }
443  };
444 
445  class MatchRules : public TypedGroup<MatchRule>
446  {
447  private:
448  explicit
449  MatchRules (const Group& group)
450  : TypedGroup<MatchRule> (group)
451  {
452  }
453 
454  friend class ProductSnapshot;
455  };
456 
457  /// Quote size rule.
458  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
459  {
460  public:
461 
462  /// Minimum bid quantity (identical to minimum offer quantity).
463  bool minBidSize (Decimal& size) const
464  {
465  return get (Tags::MinBidSize).toNumber (size);
466  }
467 
468  /// Minimum offer quantity (identical to minimum bid quantity).
469  bool minOfferSize (Decimal& size) const
470  {
471  return get (Tags::MinOfferSize).toNumber (size);
472  }
473 
474  /// Indicates if product is in the state Fast Market.
475  bool fastMarketIndicator() const
476  {
477  UInt32 value;
478  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
479  }
480 
481  private:
482  friend class TypedGroup<QuoteSizeRule>;
483 
484  QuoteSizeRule (const GroupInstance& groupInstance)
485  : GroupInstance (groupInstance)
486  {
487  }
488  };
489 
490  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
491  {
492  private:
493  explicit
494  QuoteSizeRules (const Group& group)
495  : TypedGroup<QuoteSizeRule> (group)
496  {
497  }
498 
499  friend class ProductSnapshot;
500  };
501 
502  /// Flex rule.
503  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
504  {
505  public:
506 
507  /// Defines the strategy types available for user defined strategies.
509  {
510  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
511  }
512 
513  /// Defines if user defined strategies are allowed.
515  {
516  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
517  }
518 
519  private:
520  friend class TypedGroup<FlexRule>;
521 
522  FlexRule (const GroupInstance& groupInstance)
523  : GroupInstance (groupInstance)
524  {
525  }
526  };
527 
528  class FlexRules : public TypedGroup<FlexRule>
529  {
530  private:
531  explicit
532  FlexRules (const Group& group)
533  : TypedGroup<FlexRule> (group)
534  {
535  }
536 
537  friend class ProductSnapshot;
538  };
539 
540 
541  /// Auction type rule.
542  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
543  {
544  public:
545  /// Defines the type of auction.
547  {
548  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
549  }
550 
551  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
553  {
554  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
555  }
556 
557  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
558  /// order interruption phase a surplus (side and volume) at the indicative price
559  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
560  /// is displayed to the market.
562  {
563  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
564  }
565 
566  /// Defines, if On Book trading is disabled
568  {
569  return getIntEnumFieldValue<DisableOnBookTrading>(*this, Tags::DisableOnBookTrading);
570  }
571 
572  private:
574 
575  AuctionTypeRule (const GroupInstance& groupInstance)
576  : GroupInstance (groupInstance)
577  {
578  }
579  };
580 
581  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
582  {
583  private:
584  explicit
585  AuctionTypeRules (const Group& group)
587  {
588  }
589 
590  friend class ProductSnapshot;
591  };
592 
593  /// Feed
594  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
595  {
596  public:
597 
598  /// Feed type.
600  {
601  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
602  }
603 
604  /// Book type.
606  {
607  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
608  }
609 
610  /// Maximum number of price levels for the product.
611  bool marketDepth (UInt32& depth) const
612  {
613  return get (Tags::MarketDepth).toNumber (depth);
614  }
615 
616  /// Netting interval for low bandwidth feeds (0=no netting).
617  bool marketDepthTimeInterval (UInt32& interval) const
618  {
619  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
620  }
621 
622  /// Recovery interval (duration of one cycle).
623  bool mdRecoveryTimeInterval (UInt32& interval) const
624  {
625  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
626  }
627 
628  /// IP Address for Service A.
630  {
631  StringRef val;
632  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
633  }
634 
635  /// Port number for IP address Service A.
637  {
638  return getUInt32 (Tags::PrimaryServiceLocationSubID);
639  }
640 
641  /// IP Address for Service B.
643  {
644  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
645  }
646 
647  /// Port number for IP address Service B.
648  bool mdSecondaryFeedLineSubID (UInt32& subId) const
649  {
650  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
651  }
652 
653  private:
654  friend class TypedGroup<Feed>;
655 
656  Feed (const GroupInstance& groupInstance)
657  : GroupInstance (groupInstance)
658  {
659  }
660  };
661 
662  class Feeds : public TypedGroup<Feed>
663  {
664  private:
665  explicit
666  Feeds (const Group& group)
667  : TypedGroup<Feed> (group)
668  {
669  }
670 
671  friend class ProductSnapshot;
672  };
673 
674  /// Price range rule.
675  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
676  {
677  public:
678 
679  /// Table identifier, not unique within repeating group.
681  {
682  return getUInt32 (Tags::PriceRangeRuleID);
683  }
684 
685  ///
687  {
688  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
689  }
690 
691  /// Start of price range (inclusive).
693  {
694  return getDecimal (Tags::StartPriceRange);
695  }
696 
697  /// End of price range (non-inclusive).
699  {
700  return getDecimal (Tags::EndPriceRange);
701  }
702 
703  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
704  bool priceRangeValue (Decimal& value) const
705  {
706  return get (Tags::PriceRangeValue).toNumber (value);
707  }
708 
709  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
710  bool priceRangePercentage (Decimal& percentage) const
711  {
712  return get (Tags::PriceRangePercentage).toNumber (percentage);
713  }
714 
715  private:
716  friend class TypedGroup<PriceRangeRule>;
717 
718  PriceRangeRule (const GroupInstance& groupInstance)
719  : GroupInstance (groupInstance)
720  {
721  }
722  };
723 
724  class PriceRangeRules : public TypedGroup<PriceRangeRule>
725  {
726  private:
727  explicit
728  PriceRangeRules (const Group& group)
730  {
731  }
732 
733  friend class ProductSnapshot;
734  };
735 
736  /// Herfindahl-Hirschman Index (HHI) interval.
737  class ONIXS_EUREX_EMDI_API HHIInterval : GroupInstance
738  {
739  public:
740 
741  /// The HHIInterval value.
743  {
744  return getUInt32(Tags::HHIIndicator);
745  }
746 
747  /// The HHIInterval upper boundary.
749  {
750  return getDecimal(Tags::HHIIntervalEnd);
751  }
752 
753 
754  private:
755  friend class TypedGroup<HHIInterval>;
756 
757  HHIInterval(const GroupInstance& groupInstance)
758  : GroupInstance(groupInstance)
759  {
760  }
761  };
762 
763  /// Herfindahl-Hirschman Index (HHI) intervals.
764  class HHIIntervals : public TypedGroup<HHIInterval>
765  {
766  private:
767  explicit
768  HHIIntervals(const Group& group)
769  : TypedGroup<HHIInterval>(group)
770  {
771  }
772 
773  friend class ProductSnapshot;
774  };
775 
776  /// Instrument Scope.
777  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
778  {
779  public:
780 
781  /// Instrument scope operator.
783  {
784  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
785  }
786 
787  /// Type of security.
789  {
790  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
791  }
792 
793  /// Standard strategy type for complex instruments.
795  {
796  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
797  }
798 
799  private:
801 
802  InstrumentScope (const GroupInstance& groupInstance)
803  : GroupInstance (groupInstance)
804  {
805  }
806  };
807 
808  class InstrumentScopes : public TypedGroup<InstrumentScope>
809  {
810  private:
811  explicit
812  InstrumentScopes (const Group& group)
814  {
815  }
816 
817  friend class ProductSnapshot;
818  };
819 
820 
821  /// Related Market Segments.
822  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
823  {
824  public:
825 
826  /// Market segment identifier.
828  {
829  return getUInt32 (Tags::RelatedMarketSegmentID);
830  }
831 
832  /// Defines the type of the relationship..
834  {
835  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
836  }
837 
838  /// Defines the type of the relationship..
840  {
841  return getIntEnumFieldValue<AllowOneProductStrip>(*this, Tags::AllowOneProductStrip);
842  }
843 
844  private:
846 
847  RelatedMarketSegment (const GroupInstance& groupInstance)
848  : GroupInstance (groupInstance)
849  {
850  }
851  };
852 
853  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
854  {
855  private:
856  explicit
857  RelatedMarketSegments (const Group& group)
859  {
860  }
861 
862  friend class ProductSnapshot;
863  };
864 
865 
866  /// Quantity Scaling Factors
867  class ONIXS_EUREX_EMDI_API QuantityScalingFactor : GroupInstance
868  {
869  public:
870  ///
872  {
873  return getUInt32 (Tags::QuantityScalingFactor);
874  }
875 
876  private:
878 
879  QuantityScalingFactor (const GroupInstance& groupInstance)
880  : GroupInstance (groupInstance)
881  {
882  }
883  };
884 
885  class QuantityScalingFactors : public TypedGroup<QuantityScalingFactor>
886  {
887  private:
888  explicit
889  QuantityScalingFactors (const Group& group)
891  {
892  }
893 
894  friend class ProductSnapshot;
895  };
896 
897 
898  /// Product snapshot.
899  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
900  {
901  public:
902 
903  /// Market Identifier Code as specified in ISO 10383.
905  {
906  return getStringRef (Tags::MarketID);
907  }
908 
909  /// Product identifier.
911  {
912  return getUInt32 (Tags::MarketSegmentID);
913  }
914 
915  /// Current business date
917  {
918  return getUInt32 (Tags::EffectiveBusinessDate);
919  }
920 
921  /// Next business date
923  {
924  return getUInt32 (Tags::NextEffectiveBusinessDate);
925  }
926 
927  /// Product name.
929  {
930  return getStringRef (Tags::MarketSegment);
931  }
932 
933  /// Currency as published in ISO 4217.
934  bool currency (StringRef& value) const
935  {
936  return get (Tags::Currency).toStringRef (value);
937  }
938 
939  /// Defines the TES security status.
941  {
942  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
943  }
944 
945  /// Partition of the product.
947  {
948  return getUInt32 (Tags::PartitionID);
949  }
950 
951  ///
953  {
954  return getUInt32 (Tags::CapacityGroupId);
955  }
956 
957  /// Contains the default and maximum duration of negotiation event in seconds.
958  bool negotiationDuration(UInt32& value) const
959  {
960  return get(Tags::NegotiationDuration).toNumber(value);
961  }
962 
963  /// Defines the TES security status.
965  {
966  return getIntEnumFieldValue<CrossMatchInstruction>(*this, Tags::CrossMatchInstructionDefault);
967  }
968 
969  /// Product Description.
970  bool marketSegmentDesc (StringRef& desc) const
971  {
972  return get (Tags::MarketSegmentDesc).toStringRef (desc);
973  }
974 
975  /// Product ISIN.
976  bool marketSegmentSymbol (StringRef& symbol) const
977  {
978  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
979  }
980 
981  /// Standard Eurex product types.
982  bool parentMktSegmID (StringRef& id) const
983  {
984  return get (Tags::ParentMktSegmID).toStringRef (id);
985  }
986 
987  /// Difference in number of months of the earliest expiration of a component trade as compared to the basket expiration. Only filled when ParentMktSgmnID is BTRF or EBB.
988  bool maxDiffExpMonths(UInt32& value) const
989  {
990  return get(Tags::MaxDiffExpMonths).toNumber(value);
991  }
992 
993  /// Market Segmen type.
995  {
996  return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
997  }
998 
999  /// Market Segmen type.
1001  {
1002  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
1003  }
1004 
1005  /// Market Segment subtype.
1007  {
1008  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
1009  }
1010 
1011  ///
1013  {
1014  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
1015  }
1016 
1017  /// Defines the max expiry time in seconds describing when the RFQ session will be
1018  /// automatically terminated.
1019  bool maxOffsetRFQExpireTime(UInt32& value) const
1020  {
1021  return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
1022  }
1023 
1024  /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
1025  bool offsetSTPEffectiveTime(UInt32& value) const
1026  {
1027  return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
1028  }
1029 
1030  /// TSL product group ID
1031  bool tslMarketGroupID(UInt32& value) const
1032  {
1033  return get(Tags::TslMarketGroupID).toNumber(value);
1034  }
1035 
1036  /// TSL product group symbol
1037  bool tslMarketGroup(StringRef& value) const
1038  {
1039  return get(Tags::TslMarketGroup).toStringRef(value);
1040  }
1041 
1042  /// Name of the Independent System Operator (ISO) such as PJM, ERCOT, ISONE, NYISO, CAISO, etc.
1044  {
1045  return get(Tags::IndependentSystemOperator).toStringRef(value);
1046  }
1047 
1048  /// Location/ nodes within the ISO which this product covers such as Western Hub, Jersey Central Power, etc .
1049  bool locationID(StringRef& value) const
1050  {
1051  return get(Tags::LocationID).toStringRef(value);
1052  }
1053 
1054  ///
1055  bool productType (StringRef& value) const
1056  {
1057  return get (Tags::ProductType).toStringRef (value);
1058  }
1059 
1060  /// Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8
1062  {
1063  return get(Tags::CommodityProductClass).toStringRef(value);
1064  }
1065 
1066  /// Information about the load such as 5 MW, 25 MW, 50 MW
1067  bool commodityUnit(UInt32& value) const
1068  {
1069  return get(Tags::CommodityUnit).toNumber(value);
1070  }
1071 
1072  ///
1073  bool locationType(StringRef& value) const
1074  {
1075  return get (Tags::LocationType).toStringRef (value);
1076  }
1077 
1078  ///
1079  bool maxTradeVol(Decimal& value) const
1080  {
1081  return get (Tags::MaxTradeVol).toNumber(value);
1082  }
1083 
1084  ///
1085  bool maxTradeVal(UInt64& value) const
1086  {
1087  return get (Tags::MaxTradeVal).toNumber(value);
1088  }
1089 
1090  ///
1091  bool maxCalendarSpreadVol(Decimal& value) const
1092  {
1093  return get (Tags::MaxCalendarSpreadVol).toNumber(value);
1094  }
1095 
1096  ///
1097  bool maxTESVol(Decimal& value) const
1098  {
1099  return get (Tags::MaxTESVol).toNumber(value);
1100  }
1101 
1102  ///
1104  {
1106  }
1107 
1108  /// Market Identifier Code of the underlying as specified in ISO 10383.
1110  {
1111  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
1112  }
1113 
1114  /// Underlying security symbol
1115  bool underlyingSymbol (StringRef& value) const
1116  {
1117  return get (Tags::UnderlyingSymbol).toStringRef (value);
1118  }
1119 
1120  /// ISIN code of the underlying.
1121  bool underlyingSecurityId (StringRef& value) const
1122  {
1123  return get (Tags::UnderlyingSecurityID).toStringRef (value);
1124  }
1125 
1126  /// Underlying Security ID Source.
1128  {
1129  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
1130  }
1131 
1132  /// Closing price of the underlying on the previous day.
1133  bool underlyingPrevClosePx (Decimal& price) const
1134  {
1135  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
1136  }
1137 
1138  /// Instrument Scopes.
1140  {
1141  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
1142  }
1143 
1144  /// Related Market Segments.
1146  {
1147  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
1148  }
1149 
1150  /// Tick rules.
1151  /// The group is absent for buckets, when marketSegmentSubType() is equal to
1152  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1154  {
1155  checkSequencePresence("tickRules");
1156 
1157  return TickRules (getGroup(Tags::NoTickRules) );
1158  }
1159 
1160  /// Price range rules.
1161  /// The group is absent for buckets, when marketSegmentSubType() is equal to
1162  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1164  {
1165  return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
1166  }
1167 
1168  /// Defines if one sided quotes are allowed
1170  {
1171  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
1172  }
1173 
1174  /// Defines if one sided quotes are allowed
1176  {
1177  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
1178  }
1179 
1180  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
1181  /// has to be extended to obtain the valid price range during Fast Market
1182  bool fastMarketPercentage (Decimal& value) const
1183  {
1184  return get (Tags::FastMarketPercentage).toNumber (value);
1185  }
1186 
1187  /// Specifies if Market Orders will be checked against the available bid/ask price on the opposing side in specific scenarios.
1188  bool checkMarketOrder() const
1189  {
1190  UInt32 value;
1191  return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
1192  }
1193 
1194  /// Herfindahl-Hirschman Index (HHI) intervals.
1196  {
1197  return HHIIntervals(getOptionalGroup(Tags::NoHHIIntervals));
1198  }
1199 
1200  /// Quote size rules.
1202  {
1203  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
1204  }
1205 
1206  /// Flex rules.
1208  {
1209  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
1210  }
1211 
1212  /// Minimum Tradable Unit in derivatives markets.
1213  bool roundLot(Decimal& value) const
1214  {
1215  return get(Tags::RoundLot).toNumber(value);
1216  }
1217 
1218  /// Match rules.
1220  {
1221  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
1222  }
1223 
1224  /// Match rules.
1225  /// The group is absent for buckets, when marketSegmentSubType() is equal to
1226  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1228  {
1229  checkSequencePresence("matchRules");
1230  return MatchRules (getGroup(Tags::NoMatchRules) );
1231  }
1232 
1233  /// Feeds
1234  /// The group is absent for buckets, when marketSegmentSubType() is equal to
1235  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1236  Feeds feeds() const
1237  {
1238  checkSequencePresence("feeds");
1239  return Feeds (getGroup(Tags::NoMDFeedTypes) );
1240  }
1241 
1242  private:
1243  friend class ProductSnapshotWrapper;
1244 
1245  ProductSnapshot (const void* impl)
1246  : Message (impl)
1247  {
1248  }
1249 
1250  void checkSequencePresence(const char* seqName) const
1251  {
1252  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket || marketSegmentSubType() == MarketSegmentSubType::EBBBucket)
1253  {
1254  const std::string enhancedName =
1255  std::string("Rdi ProductSnapshot::") + seqName;
1256 
1257  throw OperationException(
1258  enhancedName.c_str(), "The sequence is absent for BTRFBucket and EBBBucket subtypes");
1259  }
1260  }
1261  };
1262  }
1263  }
1264 }
bool tslMarketGroup(StringRef &value) const
TSL product group symbol.
bool maxTradeVol(Decimal &value) const
StringRef marketId() const
Market Identifier Code as specified in ISO 10383.
const Tag NoQuantityScalingFactors
Definition: Tags.h:344
bool currency(StringRef &value) const
Currency as published in ISO 4217.
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.
bool maxCalendarSpreadVol(Decimal &value) const
const Tag MatchRuleProductComplex
Definition: Tags.h:140
UInt32 hHIIndicator() const
The HHIInterval value.
StringRef mdPrimaryFeedLineID() const
IP Address for Service A.
const Tag UnderlyingSecurityID
Definition: Tags.h:157
bool independentSystemOperator(StringRef &value) const
Name of the Independent System Operator (ISO) such as PJM, ERCOT, ISONE, NYISO, CAISO, etc.
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 MaxCalendarSpreadVol
Definition: Tags.h:352
const Tag MarketSegmentSymbol
Definition: Tags.h:118
const Tag MarketSegmentSubType
Definition: Tags.h:200
Tick rule scope definitions.
bool productType(StringRef &value) const
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.
const Tag QuantityScalingFactor
Definition: Tags.h:343
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. ...
MarketSegmentSubType::Enum marketSegmentSubType() const
Market Segment subtype.
AuctionType::Enum auctionType() const
Defines the type of auction.
Herfindahl-Hirschman Index (HHI) interval.
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 CommodityProductClass
Definition: Tags.h:326
const Tag NextEffectiveBusinessDate
Definition: Tags.h:198
unsigned int UInt32
Definition: Numeric.h:41
const Tag DisableOnBookTrading
Definition: Tags.h:319
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.
bool commodityProductClass(StringRef &value) const
Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8.
bool maxDiffExpMonths(UInt32 &value) const
Difference in number of months of the earliest expiration of a component trade as compared to the bas...
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...
const Tag IndependentSystemOperator
Definition: Tags.h:323
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
bool locationType(StringRef &value) const
const Tag MDRecoveryTimeInterval
Definition: Tags.h:153
bool locationID(StringRef &value) const
Location/ nodes within the ISO which this product covers such as Western Hub, Jersey Central Power...
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.
Decimal hHIIntervalEnd() const
The HHIInterval upper boundary.
bool minBidSize(Decimal &size) const
Minimum bid quantity (identical to minimum offer quantity).
bool tslMarketGroupID(UInt32 &value) const
TSL product group ID.
const Tag PriceRangePercentage
Definition: Tags.h:131
const Tag UnderlyingSecurityIDSource
Definition: Tags.h:155
Exposes list of available closed book indicators.
Herfindahl-Hirschman Index (HHI) intervals.
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.
DisableOnBookTrading::Enum disableOnBookTrading() const
Defines, if On Book trading is disabled.
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).
bool commodityUnit(UInt32 &value) const
Information about the load such as 5 MW, 25 MW, 50 MW.
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
const Tag AllowOneProductStrip
Definition: Tags.h:329
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.
const Tag CrossMatchInstructionDefault
Definition: Tags.h:373
InstrumentType::Enum flexProductEligibilityComplex() const
Defines the strategy types available for user defined strategies.
CrossMatchInstruction::Enum crossMatchInstructionDefault() const
Defines the TES security status.
BookType::Enum mdBookType() const
Book type.
HHIIntervals hHIIntervals() const
Herfindahl-Hirschman Index (HHI) intervals.
bool underlyingSecurityIdSource(StringRef &value) const
Underlying Security ID Source.
AllowOneProductStrip::Enum allowOneProductStrip() const
Defines the type of the relationship..
PartitionId partitionId() const
Partition of the product.
QuantityScalingFactors quantityScalingFactors() const
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