OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  15.0.6
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  CommodityGroup = 3,
271  };
272  };
273 
274  /// Exposes list of available Decay splits.
275  struct ONIXS_EUREX_EMDI_API DecaySplit
276  {
277  enum Enum
278  {
279  /// Used to identify absence of value.
280  Undefined = -1,
281 
282  ///
283  Month = 0,
284 
285  ///
286  Quarter = 1,
287 
288  ///
289  Season = 2,
290 
291  ///
292  Year = 3,
293  };
294  };
295 
296  /// Exposes list of available auction types.
297  struct ONIXS_EUREX_EMDI_API AuctionType
298  {
299  enum Enum
300  {
301  /// Used to identify absence of value.
302  Undefined = -1,
303 
304  ///
305  AnyAuction = 0,
306  };
307  };
308 
309  /// Exposes list of available closed book indicators.
310  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
311  {
312  enum Enum
313  {
314  /// Used to identify absence of value.
315  Undefined = -1,
316 
317  ///
318  No = 0,
319 
320  ///
321  Yes = 1,
322  };
323  };
324 
325  /// Exposes list of available market imbalance indicators.
326  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
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  ///
342  struct ONIXS_EUREX_EMDI_API DisableOnBookTrading
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  /// Exposes list of available market segment relationship types.
358  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
359  {
360  enum Enum
361  {
362  /// Used to identify absence of value.
363  Undefined = -1,
364 
365  ///
366  CashLegForVolatilityStrategies = 0,
367 
368  ///
369  TargetProductForDecayingProduct = 1,
370 
371  ///
372  BTRFBucket = 2,
373 
374  ///
375  EBBBucket = 3,
376 
377  ///
378  CommodityGroup = 4,
379  };
380  };
381 
382  struct ONIXS_EUREX_EMDI_API AllowOneProductStrip
383  {
384  enum Enum
385  {
386  /// Used to identify absence of value.
387  Undefined = -1,
388 
389  ///
390  OneProductStripNotAllowed = 0,
391 
392  ///
393  OneProductStripNot = 1,
394  };
395  };
396 
397  /// Match rule.
398  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
399  {
400  public:
401  /// Defines the instrument type for the match rule.
403  {
404  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
405  }
406 
407  /// Defines the matching algorithm.
409  {
410  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
411  }
412 
413  /// Defines the matching type.
414  /// @note Absence means no distinction between continuous and auctions
416  {
417  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
418  }
419 
420  private:
421  friend class TypedGroup<MatchRule>;
422 
423  MatchRule (const GroupInstance& groupInstance)
424  : GroupInstance (groupInstance)
425  {
426  }
427  };
428 
429  class MatchRules : public TypedGroup<MatchRule>
430  {
431  private:
432  explicit
433  MatchRules (const Group& group)
434  : TypedGroup<MatchRule> (group)
435  {
436  }
437 
438  friend class ProductSnapshot;
439  };
440 
441  /// Quote size rule.
442  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
443  {
444  public:
445 
446  /// Minimum bid quantity (identical to minimum offer quantity).
447  bool minBidSize (Decimal& size) const
448  {
449  return get (Tags::MinBidSize).toNumber (size);
450  }
451 
452  /// Minimum offer quantity (identical to minimum bid quantity).
453  bool minOfferSize (Decimal& size) const
454  {
455  return get (Tags::MinOfferSize).toNumber (size);
456  }
457 
458  /// Indicates if product is in the state Fast Market.
459  bool fastMarketIndicator() const
460  {
461  UInt32 value;
462  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
463  }
464 
465  private:
466  friend class TypedGroup<QuoteSizeRule>;
467 
468  QuoteSizeRule (const GroupInstance& groupInstance)
469  : GroupInstance (groupInstance)
470  {
471  }
472  };
473 
474  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
475  {
476  private:
477  explicit
478  QuoteSizeRules (const Group& group)
479  : TypedGroup<QuoteSizeRule> (group)
480  {
481  }
482 
483  friend class ProductSnapshot;
484  };
485 
486  /// Flex rule.
487  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
488  {
489  public:
490 
491  /// Defines the strategy types available for user defined strategies.
493  {
494  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
495  }
496 
497  /// Defines if user defined strategies are allowed.
499  {
500  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
501  }
502 
503  private:
504  friend class TypedGroup<FlexRule>;
505 
506  FlexRule (const GroupInstance& groupInstance)
507  : GroupInstance (groupInstance)
508  {
509  }
510  };
511 
512  class FlexRules : public TypedGroup<FlexRule>
513  {
514  private:
515  explicit
516  FlexRules (const Group& group)
517  : TypedGroup<FlexRule> (group)
518  {
519  }
520 
521  friend class ProductSnapshot;
522  };
523 
524 
525  /// Auction type rule.
526  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
527  {
528  public:
529  /// Defines the type of auction.
531  {
532  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
533  }
534 
535  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
537  {
538  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
539  }
540 
541  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
542  /// order interruption phase a surplus (side and volume) at the indicative price
543  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
544  /// is displayed to the market.
546  {
547  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
548  }
549 
550  /// Defines, if On Book trading is disabled
552  {
553  return getIntEnumFieldValue<DisableOnBookTrading>(*this, Tags::DisableOnBookTrading);
554  }
555 
556  private:
558 
559  AuctionTypeRule (const GroupInstance& groupInstance)
560  : GroupInstance (groupInstance)
561  {
562  }
563  };
564 
565  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
566  {
567  private:
568  explicit
569  AuctionTypeRules (const Group& group)
571  {
572  }
573 
574  friend class ProductSnapshot;
575  };
576 
577  /// Feed
578  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
579  {
580  public:
581 
582  /// Feed type.
584  {
585  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
586  }
587 
588  /// Book type.
590  {
591  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
592  }
593 
594  /// Maximum number of price levels for the product.
595  bool marketDepth (UInt32& depth) const
596  {
597  return get (Tags::MarketDepth).toNumber (depth);
598  }
599 
600  /// Netting interval for low bandwidth feeds (0=no netting).
601  bool marketDepthTimeInterval (UInt32& interval) const
602  {
603  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
604  }
605 
606  /// Recovery interval (duration of one cycle).
607  bool mdRecoveryTimeInterval (UInt32& interval) const
608  {
609  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
610  }
611 
612  /// IP Address for Service A.
614  {
615  StringRef val;
616  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
617  }
618 
619  /// Port number for IP address Service A.
621  {
622  return getUInt32 (Tags::PrimaryServiceLocationSubID);
623  }
624 
625  /// IP Address for Service B.
627  {
628  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
629  }
630 
631  /// Port number for IP address Service B.
632  bool mdSecondaryFeedLineSubID (UInt32& subId) const
633  {
634  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
635  }
636 
637  private:
638  friend class TypedGroup<Feed>;
639 
640  Feed (const GroupInstance& groupInstance)
641  : GroupInstance (groupInstance)
642  {
643  }
644  };
645 
646  class Feeds : public TypedGroup<Feed>
647  {
648  private:
649  explicit
650  Feeds (const Group& group)
651  : TypedGroup<Feed> (group)
652  {
653  }
654 
655  friend class ProductSnapshot;
656  };
657 
658  /// Price range rule.
659  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
660  {
661  public:
662 
663  /// Table identifier, not unique within repeating group.
665  {
666  return getUInt32 (Tags::PriceRangeRuleID);
667  }
668 
669  ///
671  {
672  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
673  }
674 
675  /// Start of price range (inclusive).
677  {
678  return getDecimal (Tags::StartPriceRange);
679  }
680 
681  /// End of price range (non-inclusive).
683  {
684  return getDecimal (Tags::EndPriceRange);
685  }
686 
687  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
688  bool priceRangeValue (Decimal& value) const
689  {
690  return get (Tags::PriceRangeValue).toNumber (value);
691  }
692 
693  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
694  bool priceRangePercentage (Decimal& percentage) const
695  {
696  return get (Tags::PriceRangePercentage).toNumber (percentage);
697  }
698 
699  private:
700  friend class TypedGroup<PriceRangeRule>;
701 
702  PriceRangeRule (const GroupInstance& groupInstance)
703  : GroupInstance (groupInstance)
704  {
705  }
706  };
707 
708  class PriceRangeRules : public TypedGroup<PriceRangeRule>
709  {
710  private:
711  explicit
712  PriceRangeRules (const Group& group)
714  {
715  }
716 
717  friend class ProductSnapshot;
718  };
719 
720  /// Herfindahl-Hirschman Index (HHI) interval.
721  class ONIXS_EUREX_EMDI_API HHIInterval : GroupInstance
722  {
723  public:
724 
725  /// The HHIInterval value.
727  {
728  return getUInt32(Tags::HHIIndicator);
729  }
730 
731  /// The HHIInterval upper boundary.
733  {
734  return getDecimal(Tags::HHIIntervalEnd);
735  }
736 
737 
738  private:
739  friend class TypedGroup<HHIInterval>;
740 
741  HHIInterval(const GroupInstance& groupInstance)
742  : GroupInstance(groupInstance)
743  {
744  }
745  };
746 
747  /// Herfindahl-Hirschman Index (HHI) intervals.
748  class HHIIntervals : public TypedGroup<HHIInterval>
749  {
750  private:
751  explicit
752  HHIIntervals(const Group& group)
753  : TypedGroup<HHIInterval>(group)
754  {
755  }
756 
757  friend class ProductSnapshot;
758  };
759 
760  /// Instrument Scope.
761  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
762  {
763  public:
764 
765  /// Instrument scope operator.
767  {
768  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
769  }
770 
771  /// Type of security.
773  {
774  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
775  }
776 
777  /// Standard strategy type for complex instruments.
779  {
780  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
781  }
782 
783  private:
785 
786  InstrumentScope (const GroupInstance& groupInstance)
787  : GroupInstance (groupInstance)
788  {
789  }
790  };
791 
792  class InstrumentScopes : public TypedGroup<InstrumentScope>
793  {
794  private:
795  explicit
796  InstrumentScopes (const Group& group)
798  {
799  }
800 
801  friend class ProductSnapshot;
802  };
803 
804 
805  /// Related Market Segments.
806  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
807  {
808  public:
809 
810  /// Market segment identifier.
812  {
813  return getUInt32 (Tags::RelatedMarketSegmentID);
814  }
815 
816  /// Defines the type of the relationship..
818  {
819  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
820  }
821 
822  /// Defines the type of the relationship..
824  {
825  return getIntEnumFieldValue<AllowOneProductStrip>(*this, Tags::AllowOneProductStrip);
826  }
827 
828  private:
830 
831  RelatedMarketSegment (const GroupInstance& groupInstance)
832  : GroupInstance (groupInstance)
833  {
834  }
835  };
836 
837  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
838  {
839  private:
840  explicit
841  RelatedMarketSegments (const Group& group)
843  {
844  }
845 
846  friend class ProductSnapshot;
847  };
848 
849 
850  /// Quantity Scaling Factors
851  class ONIXS_EUREX_EMDI_API QuantityScalingFactor : GroupInstance
852  {
853  public:
854  ///
856  {
857  return getUInt32 (Tags::QuantityScalingFactor);
858  }
859 
860  private:
862 
863  QuantityScalingFactor (const GroupInstance& groupInstance)
864  : GroupInstance (groupInstance)
865  {
866  }
867  };
868 
869  class QuantityScalingFactors : public TypedGroup<QuantityScalingFactor>
870  {
871  private:
872  explicit
873  QuantityScalingFactors (const Group& group)
875  {
876  }
877 
878  friend class ProductSnapshot;
879  };
880 
881 
882  /// Product snapshot.
883  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
884  {
885  public:
886 
887  /// Market Identifier Code as specified in ISO 10383.
889  {
890  return getStringRef (Tags::MarketID);
891  }
892 
893  /// Product identifier.
895  {
896  return getUInt32 (Tags::MarketSegmentID);
897  }
898 
899  /// Current business date
901  {
902  return getUInt32 (Tags::EffectiveBusinessDate);
903  }
904 
905  /// Next business date
907  {
908  return getUInt32 (Tags::NextEffectiveBusinessDate);
909  }
910 
911  /// Product name.
913  {
914  return getStringRef (Tags::MarketSegment);
915  }
916 
917  /// Currency as published in ISO 4217.
918  bool currency (StringRef& value) const
919  {
920  return get (Tags::Currency).toStringRef (value);
921  }
922 
923  /// Defines the TES security status.
925  {
926  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
927  }
928 
929  /// Partition of the product.
931  {
932  return getUInt32 (Tags::PartitionID);
933  }
934 
935  ///
937  {
938  return getUInt32 (Tags::CapacityGroupId);
939  }
940 
941  /// Contains the default and maximum duration of negotiation event in seconds.
942  bool negotiationDuration(UInt32& value) const
943  {
944  return get(Tags::NegotiationDuration).toNumber(value);
945  }
946 
947  /// Product Description.
948  bool marketSegmentDesc (StringRef& desc) const
949  {
950  return get (Tags::MarketSegmentDesc).toStringRef (desc);
951  }
952 
953  /// Product ISIN.
954  bool marketSegmentSymbol (StringRef& symbol) const
955  {
956  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
957  }
958 
959  /// Standard Eurex product types.
960  bool parentMktSegmID (StringRef& id) const
961  {
962  return get (Tags::ParentMktSegmID).toStringRef (id);
963  }
964 
965  /// Market Segmen type.
967  {
968  return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
969  }
970 
971  /// Market Segmen type.
973  {
974  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
975  }
976 
977  /// Market Segment subtype.
979  {
980  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
981  }
982 
983  ///
985  {
986  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
987  }
988 
989  /// Defines the max expiry time in seconds describing when the RFQ session will be
990  /// automatically terminated.
991  bool maxOffsetRFQExpireTime(UInt32& value) const
992  {
993  return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
994  }
995 
996  /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
997  bool offsetSTPEffectiveTime(UInt32& value) const
998  {
999  return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
1000  }
1001 
1002  /// TSL product group ID
1003  bool tslMarketGroupID(UInt32& value) const
1004  {
1005  return get(Tags::TslMarketGroupID).toNumber(value);
1006  }
1007 
1008  /// TSL product group symbol
1009  bool tslMarketGroup(StringRef& value) const
1010  {
1011  return get(Tags::TslMarketGroup).toStringRef(value);
1012  }
1013 
1014  /// Name of the Independent System Operator (ISO) such as PJM, ERCOT, ISONE, NYISO, CAISO, etc.
1016  {
1017  return get(Tags::IndependentSystemOperator).toStringRef(value);
1018  }
1019 
1020  /// Location/ nodes within the ISO which this product covers such as Western Hub, Jersey Central Power, etc .
1021  bool locationID(StringRef& value) const
1022  {
1023  return get(Tags::LocationID).toStringRef(value);
1024  }
1025 
1026  ///
1027  bool productType (StringRef& value) const
1028  {
1029  return get (Tags::ProductType).toStringRef (value);
1030  }
1031 
1032  /// Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8
1033  bool powerProductClass(StringRef& value) const
1034  {
1035  return get(Tags::PowerProductClass).toStringRef(value);
1036  }
1037 
1038  /// Information about the load such as 5 MW, 25 MW, 50 MW
1039  bool powerUnitOfMeasure(UInt32& value) const
1040  {
1041  return get(Tags::PowerUnitOfMeasure).toNumber(value);
1042  }
1043 
1044  ///
1046  {
1048  }
1049 
1050  /// Market Identifier Code of the underlying as specified in ISO 10383.
1052  {
1053  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
1054  }
1055 
1056  /// Underlying security symbol
1057  bool underlyingSymbol (StringRef& value) const
1058  {
1059  return get (Tags::UnderlyingSymbol).toStringRef (value);
1060  }
1061 
1062  /// ISIN code of the underlying.
1063  bool underlyingSecurityId (StringRef& value) const
1064  {
1065  return get (Tags::UnderlyingSecurityID).toStringRef (value);
1066  }
1067 
1068  /// Underlying Security ID Source.
1070  {
1071  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
1072  }
1073 
1074  /// Closing price of the underlying on the previous day.
1075  bool underlyingPrevClosePx (Decimal& price) const
1076  {
1077  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
1078  }
1079 
1080  /// Instrument Scopes.
1082  {
1083  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
1084  }
1085 
1086  /// Related Market Segments.
1088  {
1089  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
1090  }
1091 
1092  /// Tick rules.
1093  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1094  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1096  {
1097  checkSequencePresence("tickRules");
1098 
1099  return TickRules (getGroup(Tags::NoTickRules) );
1100  }
1101 
1102  /// Price range rules.
1103  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1104  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1106  {
1107  return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
1108  }
1109 
1110  /// Defines if one sided quotes are allowed
1112  {
1113  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
1114  }
1115 
1116  /// Defines if one sided quotes are allowed
1118  {
1119  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
1120  }
1121 
1122  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
1123  /// has to be extended to obtain the valid price range during Fast Market
1124  bool fastMarketPercentage (Decimal& value) const
1125  {
1126  return get (Tags::FastMarketPercentage).toNumber (value);
1127  }
1128 
1129  /// Specifies if Market Orders will be checked against the available bid/ask price on the opposing side in specifc scenarios.
1130  bool checkMarketOrder() const
1131  {
1132  UInt32 value;
1133  return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
1134  }
1135 
1136  /// Herfindahl-Hirschman Index (HHI) intervals.
1138  {
1139  return HHIIntervals(getOptionalGroup(Tags::NoHHIIntervals));
1140  }
1141 
1142  /// Quote size rules.
1144  {
1145  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
1146  }
1147 
1148  /// Flex rules.
1150  {
1151  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
1152  }
1153 
1154  /// Minimum Tradable Unit in derivatives markets.
1155  bool roundLot(Decimal& value) const
1156  {
1157  return get(Tags::RoundLot).toNumber(value);
1158  }
1159 
1160  /// Match rules.
1162  {
1163  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
1164  }
1165 
1166  /// Match rules.
1167  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1168  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1170  {
1171  checkSequencePresence("matchRules");
1172  return MatchRules (getGroup(Tags::NoMatchRules) );
1173  }
1174 
1175  /// Feeds
1176  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1177  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1178  Feeds feeds() const
1179  {
1180  checkSequencePresence("feeds");
1181  return Feeds (getGroup(Tags::NoMDFeedTypes) );
1182  }
1183 
1184  private:
1185  friend class ProductSnapshotWrapper;
1186 
1187  ProductSnapshot (const void* impl)
1188  : Message (impl)
1189  {
1190  }
1191 
1192  void checkSequencePresence(const char* seqName) const
1193  {
1194  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket || marketSegmentSubType() == MarketSegmentSubType::EBBBucket)
1195  {
1196  const std::string enhancedName =
1197  std::string("Rdi ProductSnapshot::") + seqName;
1198 
1199  throw OperationException(
1200  enhancedName.c_str(), "The sequence is absent for BTRFBucket and EBBBucket subtypes");
1201  }
1202  }
1203  };
1204  }
1205  }
1206 }
bool tslMarketGroup(StringRef &value) const
TSL product group symbol.
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.
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 MarketSegmentSymbol
Definition: Tags.h:118
const Tag MarketSegmentSubType
Definition: Tags.h:200
Tick rule scope definitions.
bool powerProductClass(StringRef &value) const
Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8.
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. ...
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.
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 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.
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
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.
bool powerUnitOfMeasure(UInt32 &value) const
Information about the load such as 5 MW, 25 MW, 50 MW.
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
const Tag PowerUnitOfMeasure
Definition: Tags.h:327
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
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.
InstrumentType::Enum flexProductEligibilityComplex() const
Defines the strategy types available for user defined strategies.
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