OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  13.1.0
API documentation
ProductSnapshot.h
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable OnixS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #pragma once
21 
28 
29 
30 namespace OnixS
31 {
32  namespace Eurex
33  {
34  namespace MarketData
35  {
36  /// Exposes list of available Quote side indicators.
37  struct ONIXS_EUREX_EMDI_API QuoteSideIndicator
38  {
39  enum Enum
40  {
41  /// Used to identify absence of value.
42  Undefined = -1,
43 
44  /// Not allowed
45  OneSidedQuoteNotAllowed = 0,
46 
47  /// Allowed
48  OneSidedQuoteAllowed = 1,
49  };
50  };
51 
52  /// Exposes list of available quote side model types.
53  struct ONIXS_EUREX_EMDI_API QuoteSideModelType
54  {
55  enum Enum
56  {
57  /// Used to identify absence of value.
58  Undefined = -1,
59 
60  /// Single-sided quotes not supported
61  SSQNotSupported = 0,
62 
63  /// Single-sided quotes supported
64  SSQSupported = 1,
65  };
66  };
67 
68  /// Exposes list of available feed types.
69  struct ONIXS_EUREX_EMDI_API FeedType
70  {
71  enum Enum
72  {
73  /// Used to identify absence of value.
74  Undefined = -1,
75 
76  /// Defines if product is traded on on NTA.
77  HighIncremental = 0,
78 
79  /// Defines if product is still traded on "Eurex classic"
80  HighSnapshot = 1,
81 
82  /// Defines if product is still traded on "Eurex classic"
83  Low = 2,
84  };
85  };
86 
87  class ONIXS_EUREX_EMDI_API TickRuleScope : GroupInstance
88  {
89  public:
90  /// Defines the instrument type for the tick rule.
92  {
93  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::TickRuleProductComplex);
94  }
95 
96  /// Trade Type
98  {
99  return getIntEnumFieldValue<TrdType>(*this, Tags::TrdType);
100  }
101 
102  private:
103  friend class TypedGroup<TickRuleScope>;
104 
105  TickRuleScope (const GroupInstance& groupInstance)
106  : GroupInstance (groupInstance)
107  {
108  }
109  };
110 
111  /// Tick rule scope definitions.
112  class TickRuleScopes : public TypedGroup<TickRuleScope>
113  {
114  private:
115  explicit
116  TickRuleScopes (const Group& group)
117  : TypedGroup<TickRuleScope> (group)
118  {
119  }
120 
121  friend class TickRule;
122  };
123 
124 
125  /// Tick rule.
126  class ONIXS_EUREX_EMDI_API TickRule : GroupInstance
127  {
128  public:
129  /// Table identifier, only for cash.
131  {
132  return getUInt32 (Tags::TickRuleID);
133  }
134 
135  /// Starting price range for specified tick increment (inclusive).
137  {
138  return getDecimal (Tags::StartTickPriceRange);
139  }
140 
141  /// Ending price range for the specified tick increment (noninclusive).
143  {
144  return getDecimal (Tags::EndTickPriceRange);
145  }
146 
147  /// Tick increment for stated price range. Specifies the valid price
148  /// increments at which instrument of the product can be quoted and
149  /// traded.
151  {
152  return getDecimal (Tags::TickIncrement);
153  }
154 
155  /// Tick rule scope definitions.
157  {
158  return TickRuleScopes ( getOptionalGroup (Tags::NoTickRuleScopes));
159  }
160 
161  private:
162  friend class TypedGroup<TickRule>;
163 
164  TickRule (const GroupInstance& groupInstance)
165  : GroupInstance (groupInstance)
166  {
167  }
168  };
169 
170  class TickRules : public TypedGroup<TickRule>
171  {
172  private:
173  explicit
174  TickRules (const Group& group)
175  : TypedGroup<TickRule> (group)
176  {
177  }
178 
179  friend class ProductSnapshot;
180  };
181 
182  /// Exposes list of available match algorithms.
183  struct ONIXS_EUREX_EMDI_API MatchAlgorithm
184  {
185  enum Enum
186  {
187  /// Used to identify absence of value.
188  Undefined = -1,
189 
190  ///
191  PriceTime = 0,
192 
193  ///
194  ProRata = 1,
195 
196  ///
197  TimeProRata = 2,
198  };
199  };
200 
201 
202  /// Exposes list of available match types.
203  struct ONIXS_EUREX_EMDI_API MatchType
204  {
205  enum Enum
206  {
207  /// Used to identify absence of value.
208  Undefined = -1,
209 
210  ///
211  AutoMatch = 0,
212 
213  ///
214  CallAuction = 2,
215  };
216  };
217 
218 
219  /// Exposes list of available market segment types.
220  struct ONIXS_EUREX_EMDI_API USApproval
221  {
222  enum Enum
223  {
224  /// Used to identify absence of value.
225  Undefined = -1,
226 
227  ///
228  NoApproval = 0,
229 
230  ///
231  CFTCApproved = 0,
232 
233  ///
234  SECApproved = 0,
235  };
236  };
237 
238  /// Exposes list of available market segment types.
239  struct ONIXS_EUREX_EMDI_API MarketSegmentType
240  {
241  enum Enum
242  {
243  /// Used to identify absence of value.
244  Undefined = -1,
245 
246  ///
247  Pool = 0,
248  };
249  };
250 
251 
252  /// Exposes list of available market segment subtypes.
253  struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
254  {
255  enum Enum
256  {
257  /// Used to identify absence of value.
258  Undefined = -1,
259 
260  ///
261  InterProductSpread = 0,
262 
263  ///
264  BTRFBucket = 1,
265 
266  ///
267  EBBBucket = 2,
268 
269  ///
270  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 product types
297  struct ONIXS_EUREX_EMDI_API ProductType
298  {
299  enum Enum
300  {
301  /// Used to identify absence of value.
302  Undefined = -1,
303 
304  ///
305  DayAhead = 0,
306 
307  ///
308  Realtime = 1,
309  };
310  };
311 
312 
313  /// Exposes list of available auction types.
314  struct ONIXS_EUREX_EMDI_API AuctionType
315  {
316  enum Enum
317  {
318  /// Used to identify absence of value.
319  Undefined = -1,
320 
321  ///
322  AnyAuction = 0,
323  };
324  };
325 
326  /// Exposes list of available closed book indicators.
327  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
328  {
329  enum Enum
330  {
331  /// Used to identify absence of value.
332  Undefined = -1,
333 
334  ///
335  No = 0,
336 
337  ///
338  Yes = 1,
339  };
340  };
341 
342  /// Exposes list of available market imbalance indicators.
343  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
344  {
345  enum Enum
346  {
347  /// Used to identify absence of value.
348  Undefined = -1,
349 
350  ///
351  No = 0,
352 
353  ///
354  Yes = 1,
355  };
356  };
357 
358  ///
359  struct ONIXS_EUREX_EMDI_API DisableOnBookTrading
360  {
361  enum Enum
362  {
363  /// Used to identify absence of value.
364  Undefined = -1,
365 
366  ///
367  No = 0,
368 
369  ///
370  Yes = 1,
371  };
372  };
373 
374  /// Exposes list of available market segment relationship types.
375  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
376  {
377  enum Enum
378  {
379  /// Used to identify absence of value.
380  Undefined = -1,
381 
382  ///
383  CashLegForVolatilityStrategies = 0,
384 
385  ///
386  TargetProductForDecayingProduct = 1,
387 
388  ///
389  BTRFBucket = 2,
390 
391  ///
392  EBBBucket = 3,
393 
394  ///
395  CommodityGroup = 4,
396  };
397  };
398 
399  struct ONIXS_EUREX_EMDI_API AllowOneProductStrip
400  {
401  enum Enum
402  {
403  /// Used to identify absence of value.
404  Undefined = -1,
405 
406  ///
407  OneProductStripNotAllowed = 0,
408 
409  ///
410  OneProductStripNot = 1,
411  };
412  };
413 
414  /// Match rule.
415  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
416  {
417  public:
418  /// Defines the instrument type for the match rule.
420  {
421  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
422  }
423 
424  /// Defines the matching algorithm.
426  {
427  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
428  }
429 
430  /// Defines the matching type.
431  /// @note Absence means no distinction between continuous and auctions
433  {
434  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
435  }
436 
437  private:
438  friend class TypedGroup<MatchRule>;
439 
440  MatchRule (const GroupInstance& groupInstance)
441  : GroupInstance (groupInstance)
442  {
443  }
444  };
445 
446  class MatchRules : public TypedGroup<MatchRule>
447  {
448  private:
449  explicit
450  MatchRules (const Group& group)
451  : TypedGroup<MatchRule> (group)
452  {
453  }
454 
455  friend class ProductSnapshot;
456  };
457 
458  /// Quote size rule.
459  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
460  {
461  public:
462 
463  /// Minimum bid quantity (identical to minimum offer quantity).
464  bool minBidSize (Decimal& size) const
465  {
466  return get (Tags::MinBidSize).toNumber (size);
467  }
468 
469  /// Minimum offer quantity (identical to minimum bid quantity).
470  bool minOfferSize (Decimal& size) const
471  {
472  return get (Tags::MinOfferSize).toNumber (size);
473  }
474 
475  /// Indicates if product is in the state Fast Market.
476  bool fastMarketIndicator() const
477  {
478  UInt32 value;
479  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
480  }
481 
482  private:
483  friend class TypedGroup<QuoteSizeRule>;
484 
485  QuoteSizeRule (const GroupInstance& groupInstance)
486  : GroupInstance (groupInstance)
487  {
488  }
489  };
490 
491  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
492  {
493  private:
494  explicit
495  QuoteSizeRules (const Group& group)
496  : TypedGroup<QuoteSizeRule> (group)
497  {
498  }
499 
500  friend class ProductSnapshot;
501  };
502 
503  /// Flex rule.
504  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
505  {
506  public:
507 
508  /// Defines the strategy types available for user defined strategies.
510  {
511  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
512  }
513 
514  /// Defines if user defined strategies are allowed.
516  {
517  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
518  }
519 
520  private:
521  friend class TypedGroup<FlexRule>;
522 
523  FlexRule (const GroupInstance& groupInstance)
524  : GroupInstance (groupInstance)
525  {
526  }
527  };
528 
529  class FlexRules : public TypedGroup<FlexRule>
530  {
531  private:
532  explicit
533  FlexRules (const Group& group)
534  : TypedGroup<FlexRule> (group)
535  {
536  }
537 
538  friend class ProductSnapshot;
539  };
540 
541 
542  /// Auction type rule.
543  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
544  {
545  public:
546  /// Defines the type of auction.
548  {
549  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
550  }
551 
552  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
554  {
555  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
556  }
557 
558  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
559  /// order interruption phase a surplus (side and volume) at the indicative price
560  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
561  /// is displayed to the market.
563  {
564  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
565  }
566 
567  /// Defines, if On Book trading is disabled
569  {
570  return getIntEnumFieldValue<DisableOnBookTrading>(*this, Tags::DisableOnBookTrading);
571  }
572 
573  private:
575 
576  AuctionTypeRule (const GroupInstance& groupInstance)
577  : GroupInstance (groupInstance)
578  {
579  }
580  };
581 
582  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
583  {
584  private:
585  explicit
586  AuctionTypeRules (const Group& group)
588  {
589  }
590 
591  friend class ProductSnapshot;
592  };
593 
594  /// Feed
595  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
596  {
597  public:
598 
599  /// Feed type.
601  {
602  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
603  }
604 
605  /// Book type.
607  {
608  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
609  }
610 
611  /// Maximum number of price levels for the product.
612  bool marketDepth (UInt32& depth) const
613  {
614  return get (Tags::MarketDepth).toNumber (depth);
615  }
616 
617  /// Netting interval for low bandwidth feeds (0=no netting).
618  bool marketDepthTimeInterval (UInt32& interval) const
619  {
620  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
621  }
622 
623  /// Recovery interval (duration of one cycle).
624  bool mdRecoveryTimeInterval (UInt32& interval) const
625  {
626  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
627  }
628 
629  /// IP Address for Service A.
631  {
632  StringRef val;
633  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
634  }
635 
636  /// Port number for IP address Service A.
638  {
639  return getUInt32 (Tags::PrimaryServiceLocationSubID);
640  }
641 
642  /// IP Address for Service B.
644  {
645  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
646  }
647 
648  /// Port number for IP address Service B.
649  bool mdSecondaryFeedLineSubID (UInt32& subId) const
650  {
651  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
652  }
653 
654  private:
655  friend class TypedGroup<Feed>;
656 
657  Feed (const GroupInstance& groupInstance)
658  : GroupInstance (groupInstance)
659  {
660  }
661  };
662 
663  class Feeds : public TypedGroup<Feed>
664  {
665  private:
666  explicit
667  Feeds (const Group& group)
668  : TypedGroup<Feed> (group)
669  {
670  }
671 
672  friend class ProductSnapshot;
673  };
674 
675  /// Price range rule.
676  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
677  {
678  public:
679 
680  /// Table identifier, not unique within repeating group.
682  {
683  return getUInt32 (Tags::PriceRangeRuleID);
684  }
685 
686  ///
688  {
689  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
690  }
691 
692  /// Start of price range (inclusive).
694  {
695  return getDecimal (Tags::StartPriceRange);
696  }
697 
698  /// End of price range (non-inclusive).
700  {
701  return getDecimal (Tags::EndPriceRange);
702  }
703 
704  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
705  bool priceRangeValue (Decimal& value) const
706  {
707  return get (Tags::PriceRangeValue).toNumber (value);
708  }
709 
710  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
711  bool priceRangePercentage (Decimal& percentage) const
712  {
713  return get (Tags::PriceRangePercentage).toNumber (percentage);
714  }
715 
716  private:
717  friend class TypedGroup<PriceRangeRule>;
718 
719  PriceRangeRule (const GroupInstance& groupInstance)
720  : GroupInstance (groupInstance)
721  {
722  }
723  };
724 
725  class PriceRangeRules : public TypedGroup<PriceRangeRule>
726  {
727  private:
728  explicit
729  PriceRangeRules (const Group& group)
731  {
732  }
733 
734  friend class ProductSnapshot;
735  };
736 
737  /// Herfindahl-Hirschman Index (HHI) interval.
738  class ONIXS_EUREX_EMDI_API HHIInterval : GroupInstance
739  {
740  public:
741 
742  /// The HHIInterval value.
744  {
745  return getUInt32(Tags::HHIIndicator);
746  }
747 
748  /// The HHIInterval upper boundary.
750  {
751  return getDecimal(Tags::HHIIntervalEnd);
752  }
753 
754 
755  private:
756  friend class TypedGroup<HHIInterval>;
757 
758  HHIInterval(const GroupInstance& groupInstance)
759  : GroupInstance(groupInstance)
760  {
761  }
762  };
763 
764  /// Herfindahl-Hirschman Index (HHI) intervals.
765  class HHIIntervals : public TypedGroup<HHIInterval>
766  {
767  private:
768  explicit
769  HHIIntervals(const Group& group)
770  : TypedGroup<HHIInterval>(group)
771  {
772  }
773 
774  friend class ProductSnapshot;
775  };
776 
777  /// Instrument Scope.
778  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
779  {
780  public:
781 
782  /// Instrument scope operator.
784  {
785  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
786  }
787 
788  /// Type of security.
790  {
791  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
792  }
793 
794  /// Standard strategy type for complex instruments.
796  {
797  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
798  }
799 
800  private:
802 
803  InstrumentScope (const GroupInstance& groupInstance)
804  : GroupInstance (groupInstance)
805  {
806  }
807  };
808 
809  class InstrumentScopes : public TypedGroup<InstrumentScope>
810  {
811  private:
812  explicit
813  InstrumentScopes (const Group& group)
815  {
816  }
817 
818  friend class ProductSnapshot;
819  };
820 
821 
822  /// Related Market Segments.
823  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
824  {
825  public:
826 
827  /// Market segment identifier.
829  {
830  return getUInt32 (Tags::RelatedMarketSegmentID);
831  }
832 
833  /// Defines the type of the relationship..
835  {
836  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
837  }
838 
839  /// Defines the type of the relationship..
841  {
842  return getIntEnumFieldValue<AllowOneProductStrip>(*this, Tags::AllowOneProductStrip);
843  }
844 
845  private:
847 
848  RelatedMarketSegment (const GroupInstance& groupInstance)
849  : GroupInstance (groupInstance)
850  {
851  }
852  };
853 
854  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
855  {
856  private:
857  explicit
858  RelatedMarketSegments (const Group& group)
860  {
861  }
862 
863  friend class ProductSnapshot;
864  };
865 
866  /// Product snapshot.
867  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
868  {
869  public:
870 
871  /// Market Identifier Code as specified in ISO 10383.
873  {
874  return getStringRef (Tags::MarketID);
875  }
876 
877  /// Product identifier.
879  {
880  return getUInt32 (Tags::MarketSegmentID);
881  }
882 
883  /// Current business date
885  {
886  return getUInt32 (Tags::EffectiveBusinessDate);
887  }
888 
889  /// Next business date
891  {
892  return getUInt32 (Tags::NextEffectiveBusinessDate);
893  }
894 
895  /// Product name.
897  {
898  return getStringRef (Tags::MarketSegment);
899  }
900 
901  /// Currency as published in ISO 4217.
902  bool currency (StringRef& value) const
903  {
904  return get (Tags::Currency).toStringRef (value);
905  }
906 
907  /// Defines the TES security status.
909  {
910  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
911  }
912 
913  /// Partition of the product.
915  {
916  return getUInt32 (Tags::PartitionID);
917  }
918 
919  /// Contains the default and maximum duration of negotiation event in seconds.
920  bool negotiationDuration(UInt32& value) const
921  {
922  return get(Tags::NegotiationDuration).toNumber(value);
923  }
924 
925  /// Product Description.
926  bool marketSegmentDesc (StringRef& desc) const
927  {
928  return get (Tags::MarketSegmentDesc).toStringRef (desc);
929  }
930 
931  /// Product ISIN.
932  bool marketSegmentSymbol (StringRef& symbol) const
933  {
934  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
935  }
936 
937  /// Standard Eurex product types.
938  bool parentMktSegmID (StringRef& id) const
939  {
940  return get (Tags::ParentMktSegmID).toStringRef (id);
941  }
942 
943  /// Market Segmen type.
945  {
946  return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
947  }
948 
949  /// Market Segmen type.
951  {
952  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
953  }
954 
955  /// Market Segment subtype.
957  {
958  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
959  }
960 
961  ///
963  {
964  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
965  }
966 
967  /// Defines the max expiry time in seconds describing when the RFQ session will be
968  /// automatically terminated.
969  bool maxOffsetRFQExpireTime(UInt32& value) const
970  {
971  return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
972  }
973 
974  /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
975  bool offsetSTPEffectiveTime(UInt32& value) const
976  {
977  return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
978  }
979 
980  /// TSL product group ID
981  bool tslMarketGroupID(UInt32& value) const
982  {
983  return get(Tags::TslMarketGroupID).toNumber(value);
984  }
985 
986  /// TSL product group symbol
987  bool tslMarketGroup(StringRef& value) const
988  {
989  return get(Tags::TslMarketGroup).toStringRef(value);
990  }
991 
992  /// Name of the Independent System Operator (ISO) such as PJM, ERCOT, ISONE, NYISO, CAISO, etc.
994  {
995  return get(Tags::IndependentSystemOperator).toStringRef(value);
996  }
997 
998  /// Location/ nodes within the ISO which this product covers such as Western Hub, Jersey Central Power, etc .
999  bool locationID(StringRef& value) const
1000  {
1001  return get(Tags::LocationID).toStringRef(value);
1002  }
1003 
1004  ///
1006  {
1007  return getIntEnumFieldValue<ProductType>(*this, Tags::ProductType);
1008  }
1009 
1010  /// Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8
1011  bool powerProductClass(StringRef& value) const
1012  {
1013  return get(Tags::PowerProductClass).toStringRef(value);
1014  }
1015 
1016  /// Information about the load such as 5 MW, 25 MW, 50 MW
1017  bool powerUnitOfMeasure(UInt32& value) const
1018  {
1019  return get(Tags::PowerUnitOfMeasure).toNumber(value);
1020  }
1021 
1022  /// Market Identifier Code of the underlying as specified in ISO 10383.
1024  {
1025  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
1026  }
1027 
1028  /// Underlying security symbol
1029  bool underlyingSymbol (StringRef& value) const
1030  {
1031  return get (Tags::UnderlyingSymbol).toStringRef (value);
1032  }
1033 
1034  /// ISIN code of the underlying.
1035  bool underlyingSecurityId (StringRef& value) const
1036  {
1037  return get (Tags::UnderlyingSecurityID).toStringRef (value);
1038  }
1039 
1040  /// Underlying Security ID Source.
1042  {
1043  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
1044  }
1045 
1046  /// Closing price of the underlying on the previous day.
1047  bool underlyingPrevClosePx (Decimal& price) const
1048  {
1049  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
1050  }
1051 
1052  /// Instrument Scopes.
1054  {
1055  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
1056  }
1057 
1058  /// Related Market Segments.
1060  {
1061  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
1062  }
1063 
1064  /// Tick rules.
1065  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1066  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1068  {
1069  checkSequencePresence("tickRules");
1070 
1071  return TickRules (getGroup(Tags::NoTickRules) );
1072  }
1073 
1074  /// Price range rules.
1075  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1076  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1078  {
1079  return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
1080  }
1081 
1082  /// Defines if one sided quotes are allowed
1084  {
1085  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
1086  }
1087 
1088  /// Defines if one sided quotes are allowed
1090  {
1091  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
1092  }
1093 
1094  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
1095  /// has to be extended to obtain the valid price range during Fast Market
1096  bool fastMarketPercentage (Decimal& value) const
1097  {
1098  return get (Tags::FastMarketPercentage).toNumber (value);
1099  }
1100 
1101  /// Specifies if Market Orders will be checked against the available bid/ask price on the opposing side in specifc scenarios.
1102  bool checkMarketOrder() const
1103  {
1104  UInt32 value;
1105  return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
1106  }
1107 
1108  /// Herfindahl-Hirschman Index (HHI) intervals.
1110  {
1111  return HHIIntervals(getOptionalGroup(Tags::NoHHIIntervals));
1112  }
1113 
1114  /// Quote size rules.
1116  {
1117  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
1118  }
1119 
1120  /// Flex rules.
1122  {
1123  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
1124  }
1125 
1126  /// Minimum Tradable Unit in derivatives markets.
1127  bool roundLot(Decimal& value) const
1128  {
1129  return get(Tags::RoundLot).toNumber(value);
1130  }
1131 
1132  /// Match rules.
1134  {
1135  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
1136  }
1137 
1138  /// Match rules.
1139  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1140  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1142  {
1143  checkSequencePresence("matchRules");
1144  return MatchRules (getGroup(Tags::NoMatchRules) );
1145  }
1146 
1147  /// Feeds
1148  /// The group is absent for buckets, when marketSegmentSubType() is equel to
1149  /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
1150  Feeds feeds() const
1151  {
1152  checkSequencePresence("feeds");
1153  return Feeds (getGroup(Tags::NoMDFeedTypes) );
1154  }
1155 
1156  private:
1157  friend class ProductSnapshotWrapper;
1158 
1159  ProductSnapshot (const void* impl)
1160  : Message (impl)
1161  {
1162  }
1163 
1164  void checkSequencePresence(const char* seqName) const
1165  {
1166  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket || marketSegmentSubType() == MarketSegmentSubType::EBBBucket)
1167  {
1168  const std::string enhancedName =
1169  std::string("Rdi ProductSnapshot::") + seqName;
1170 
1171  throw OperationException(
1172  enhancedName.c_str(), "The sequence is absent for BTRFBucket and EBBBucket subtypes");
1173  }
1174  }
1175  };
1176  }
1177  }
1178 }
bool tslMarketGroup(StringRef &value) const
TSL product group symbol.
StringRef marketId() const
Market Identifier Code as specified in ISO 10383.
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 parentMktSegmID(StringRef &id) const
Standard Eurex product types.
Exposes list of available market segment subtypes.
const Tag StartTickPriceRange
Definition: Tags.h:103
Decimal endTickPriceRange() const
Ending price range for the specified tick increment (noninclusive).
const Tag MaxOffsetRFQExpireTime
Definition: Tags.h:277
const Tag MarketSegmentStatus
Definition: Tags.h:126
const Tag ClosedBookIndicator
Definition: Tags.h:207
Exposes list of available Quote side indicators.
const Tag PrimaryServiceLocationID
Definition: Tags.h:122
const Tag SecondaryServiceLocationSubID
Definition: Tags.h:125
QuoteSideModelType::Enum quoteSideModelType() const
Defines if one sided quotes are allowed.
const Tag SecondaryServiceLocationID
Definition: Tags.h:124
FeedType::Enum mdFeedType() const
Feed type.
bool fastMarketIndicator() const
Indicates if product is in the state Fast Market.
Exposes list of available Decay splits.
FlexRules flexRules() const
Flex rules.
bool negotiationDuration(UInt32 &value) const
Contains the default and maximum duration of negotiation event in seconds.
MarketSegmentId marketSegmentId() const
Product identifier.
TickRuleScopes tickRuleScopes() const
Tick rule scope definitions.
const Tag MarketDepthTimeInterval
Definition: Tags.h:152
MarketSegmentRelationship::Enum marketSegmentRelationship() const
Defines the type of the relationship..
bool minOfferSize(Decimal &size) const
Minimum offer quantity (identical to minimum bid quantity).
UInt32 tickRuleId() const
Table identifier, only for cash.
bool offsetSTPEffectiveTime(UInt32 &value) const
Defines the waiting period of the final STP deal inside Eurex EnLight in seconds. ...
Defines all the months in the year.
Definition: Timestamp.h:35
MarketSegmentSubType::Enum marketSegmentSubType() const
Market Segment subtype.
AuctionType::Enum auctionType() const
Defines the type of auction.
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.
Exposes list of available product types.
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.
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