OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  7.4.2
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 ( getGroup (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 MarketSegmentType
221  {
222  enum Enum
223  {
224  /// Used to identify absence of value.
225  Undefined = -1,
226 
227  ///
228  Pool = 0,
229  };
230  };
231 
232 
233  /// Exposes list of available market segment subtypes.
234  struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
235  {
236  enum Enum
237  {
238  /// Used to identify absence of value.
239  Undefined = -1,
240 
241  ///
242  InterProductSpread = 0,
243 
244  ///
245  BTRFBucket = 1,
246  };
247  };
248 
249  /// Exposes list of available Decay splits.
250  struct ONIXS_EUREX_EMDI_API DecaySplit
251  {
252  enum Enum
253  {
254  /// Used to identify absence of value.
255  Undefined = -1,
256 
257  ///
258  Month = 0,
259 
260  ///
261  Quarter = 1,
262 
263  ///
264  Season = 2,
265 
266  ///
267  Year = 3,
268  };
269  };
270 
271  /// Exposes list of available auction types.
272  struct ONIXS_EUREX_EMDI_API AuctionType
273  {
274  enum Enum
275  {
276  /// Used to identify absence of value.
277  Undefined = -1,
278 
279  ///
280  AnyAuction = 0,
281  };
282  };
283 
284  /// Exposes list of available closed book indicators.
285  struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
286  {
287  enum Enum
288  {
289  /// Used to identify absence of value.
290  Undefined = -1,
291 
292  ///
293  No = 0,
294 
295  ///
296  Yes = 1,
297  };
298  };
299 
300  /// Exposes list of available market imbalance indicators.
301  struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
302  {
303  enum Enum
304  {
305  /// Used to identify absence of value.
306  Undefined = -1,
307 
308  ///
309  No = 0,
310 
311  ///
312  Yes = 1,
313  };
314  };
315 
316  /// Exposes list of available market segment relationship types.
317  struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
318  {
319  enum Enum
320  {
321  /// Used to identify absence of value.
322  Undefined = -1,
323 
324  ///
325  CashLegForVolatilityStrategies = 0,
326 
327  ///
328  TargetProductForDecayingProduct = 1,
329 
330  ///
331  BTRFBucket = 2,
332  };
333  };
334 
335  /// Match rule.
336  class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
337  {
338  public:
339  /// Defines the instrument type for the match rule.
341  {
342  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
343  }
344 
345  /// Defines the matching algorithm.
347  {
348  return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
349  }
350 
351  /// Defines the matching type.
352  /// @note Absence means no distinction between continuous and auctions
354  {
355  return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
356  }
357 
358  private:
359  friend class TypedGroup<MatchRule>;
360 
361  MatchRule (const GroupInstance& groupInstance)
362  : GroupInstance (groupInstance)
363  {
364  }
365  };
366 
367  class MatchRules : public TypedGroup<MatchRule>
368  {
369  private:
370  explicit
371  MatchRules (const Group& group)
372  : TypedGroup<MatchRule> (group)
373  {
374  }
375 
376  friend class ProductSnapshot;
377  };
378 
379  /// Quote size rule.
380  class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
381  {
382  public:
383 
384  /// Minimum bid quantity (identical to minimum offer quantity).
385  bool minBidSize (Decimal& size) const
386  {
387  return get (Tags::MinBidSize).toNumber (size);
388  }
389 
390  /// Minimum offer quantity (identical to minimum bid quantity).
391  bool minOfferSize (Decimal& size) const
392  {
393  return get (Tags::MinOfferSize).toNumber (size);
394  }
395 
396  /// Indicates if product is in the state Fast Market.
397  bool fastMarketIndicator() const
398  {
399  UInt32 value;
400  return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
401  }
402 
403  private:
404  friend class TypedGroup<QuoteSizeRule>;
405 
406  QuoteSizeRule (const GroupInstance& groupInstance)
407  : GroupInstance (groupInstance)
408  {
409  }
410  };
411 
412  class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
413  {
414  private:
415  explicit
416  QuoteSizeRules (const Group& group)
417  : TypedGroup<QuoteSizeRule> (group)
418  {
419  }
420 
421  friend class ProductSnapshot;
422  };
423 
424  /// Flex rule.
425  class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
426  {
427  public:
428 
429  /// Defines the strategy types available for user defined strategies.
431  {
432  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
433  }
434 
435  /// Defines if user defined strategies are allowed.
437  {
438  return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
439  }
440 
441  private:
442  friend class TypedGroup<FlexRule>;
443 
444  FlexRule (const GroupInstance& groupInstance)
445  : GroupInstance (groupInstance)
446  {
447  }
448  };
449 
450  class FlexRules : public TypedGroup<FlexRule>
451  {
452  private:
453  explicit
454  FlexRules (const Group& group)
455  : TypedGroup<FlexRule> (group)
456  {
457  }
458 
459  friend class ProductSnapshot;
460  };
461 
462 
463  /// Auction type rule.
464  class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
465  {
466  public:
467  /// Defines the type of auction.
469  {
470  return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
471  }
472 
473  /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
475  {
476  return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
477  }
478 
479  /// Controls if during auction call/volatility interruption/extended volatility interruption/market
480  /// order interruption phase a surplus (side and volume) at the indicative price
481  /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
482  /// is displayed to the market.
484  {
485  return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
486  }
487 
488  private:
490 
491  AuctionTypeRule (const GroupInstance& groupInstance)
492  : GroupInstance (groupInstance)
493  {
494  }
495  };
496 
497  class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
498  {
499  private:
500  explicit
501  AuctionTypeRules (const Group& group)
503  {
504  }
505 
506  friend class ProductSnapshot;
507  };
508 
509  /// Feed
510  class ONIXS_EUREX_EMDI_API Feed : GroupInstance
511  {
512  public:
513 
514  /// Feed type.
516  {
517  return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
518  }
519 
520  /// Book type.
522  {
523  return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
524  }
525 
526  /// Maximum number of price levels for the product.
527  bool marketDepth (UInt32& depth) const
528  {
529  return get (Tags::MarketDepth).toNumber (depth);
530  }
531 
532  /// Netting interval for low bandwidth feeds (0=no netting).
533  bool marketDepthTimeInterval (UInt32& interval) const
534  {
535  return get (Tags::MarketDepthTimeInterval).toNumber (interval);
536  }
537 
538  /// Recovery interval (duration of one cycle).
539  bool mdRecoveryTimeInterval (UInt32& interval) const
540  {
541  return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
542  }
543 
544  /// IP Address for Service A.
546  {
547  StringRef val;
548  return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
549  }
550 
551  /// Port number for IP address Service A.
553  {
554  return getUInt32 (Tags::PrimaryServiceLocationSubID);
555  }
556 
557  /// IP Address for Service B.
559  {
560  return get (Tags::SecondaryServiceLocationID).toStringRef (id);
561  }
562 
563  /// Port number for IP address Service B.
564  bool mdSecondaryFeedLineSubID (UInt32& subId) const
565  {
566  return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
567  }
568 
569  private:
570  friend class TypedGroup<Feed>;
571 
572  Feed (const GroupInstance& groupInstance)
573  : GroupInstance (groupInstance)
574  {
575  }
576  };
577 
578  class Feeds : public TypedGroup<Feed>
579  {
580  private:
581  explicit
582  Feeds (const Group& group)
583  : TypedGroup<Feed> (group)
584  {
585  }
586 
587  friend class ProductSnapshot;
588  };
589 
590  /// Price range rule.
591  class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
592  {
593  public:
594 
595  /// Table identifier, not unique within repeating group.
597  {
598  return getUInt32 (Tags::PriceRangeRuleID);
599  }
600 
601  ///
603  {
604  return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
605  }
606 
607  /// Start of price range (inclusive).
609  {
610  return getDecimal (Tags::StartPriceRange);
611  }
612 
613  /// End of price range (non-inclusive).
615  {
616  return getDecimal (Tags::EndPriceRange);
617  }
618 
619  /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
620  bool priceRangeValue (Decimal& value) const
621  {
622  return get (Tags::PriceRangeValue).toNumber (value);
623  }
624 
625  /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
626  bool priceRangePercentage (Decimal& percentage) const
627  {
628  return get (Tags::PriceRangePercentage).toNumber (percentage);
629  }
630 
631  private:
632  friend class TypedGroup<PriceRangeRule>;
633 
634  PriceRangeRule (const GroupInstance& groupInstance)
635  : GroupInstance (groupInstance)
636  {
637  }
638  };
639 
640  class PriceRangeRules : public TypedGroup<PriceRangeRule>
641  {
642  private:
643  explicit
644  PriceRangeRules (const Group& group)
646  {
647  }
648 
649  friend class ProductSnapshot;
650  };
651 
652 
653  /// Instrument Scope.
654  class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
655  {
656  public:
657 
658  /// Instrument scope operator.
660  {
661  return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
662  }
663 
664  /// Type of security.
666  {
667  return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
668  }
669 
670  /// Standard strategy type for complex instruments.
672  {
673  return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
674  }
675 
676  private:
678 
679  InstrumentScope (const GroupInstance& groupInstance)
680  : GroupInstance (groupInstance)
681  {
682  }
683  };
684 
685  class InstrumentScopes : public TypedGroup<InstrumentScope>
686  {
687  private:
688  explicit
689  InstrumentScopes (const Group& group)
691  {
692  }
693 
694  friend class ProductSnapshot;
695  };
696 
697 
698  /// Related Market Segments.
699  class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
700  {
701  public:
702 
703  /// Market segment identifier.
705  {
706  return getUInt32 (Tags::RelatedMarketSegmentID);
707  }
708 
709  /// Defines the type of the relationship..
711  {
712  return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
713  }
714 
715  private:
717 
718  RelatedMarketSegment (const GroupInstance& groupInstance)
719  : GroupInstance (groupInstance)
720  {
721  }
722  };
723 
724  class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
725  {
726  private:
727  explicit
728  RelatedMarketSegments (const Group& group)
730  {
731  }
732 
733  friend class ProductSnapshot;
734  };
735 
736  /// Product snapshot.
737  class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
738  {
739  public:
740 
741  /// Market Identifier Code as specified in ISO 10383.
743  {
744  return getStringRef (Tags::MarketID);
745  }
746 
747  /// Product identifier.
749  {
750  return getUInt32 (Tags::MarketSegmentID);
751  }
752 
753  /// Current business date
755  {
756  return getUInt32 (Tags::EffectiveBusinessDate);
757  }
758 
759  /// Next business date
761  {
762  return getUInt32 (Tags::NextEffectiveBusinessDate);
763  }
764 
765  /// Product name.
767  {
768  return getStringRef (Tags::MarketSegment);
769  }
770 
771  /// Currency as published in ISO 4217.
773  {
774  return getStringRef (Tags::Currency);
775  }
776 
777  /// Defines the TES security status.
779  {
780  return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
781  }
782 
783  /// Partition of the product.
785  {
786  return getUInt32 (Tags::PartitionID);
787  }
788 
789  /// Product Description.
790  bool marketSegmentDesc (StringRef& desc) const
791  {
792  return get (Tags::MarketSegmentDesc).toStringRef (desc);
793  }
794 
795  /// Product ISIN.
796  bool marketSegmentSymbol (StringRef& symbol) const
797  {
798  return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
799  }
800 
801  /// Standard Eurex product types.
802  bool parentMktSegmID (StringRef& id) const
803  {
804  return get (Tags::ParentMktSegmID).toStringRef (id);
805  }
806 
807  /// Flag to identify whether product may be traded from the USA.
808  bool usFirmFlag(bool& flag) const
809  {
810  UInt32 flagValue;
811  if(get(Tags::USFirmFlag).toNumber (flagValue))
812  {
813  flag = (flagValue == 1);
814  return true;
815  }
816  return false;
817  }
818 
819  /// Market Segmen type.
821  {
822  return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
823  }
824 
825  /// Market Segment subtype.
827  {
828  return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
829  }
830 
831  ///
833  {
834  return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
835  }
836 
837  /// Market Identifier Code of the underlying as specified in ISO 10383.
839  {
840  return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
841  }
842 
843  /// Underlying security symbol
844  bool underlyingSymbol (StringRef& value) const
845  {
846  return get (Tags::UnderlyingSymbol).toStringRef (value);
847  }
848 
849  /// ISIN code of the underlying.
850  bool underlyingSecurityId (StringRef& value) const
851  {
852  return get (Tags::UnderlyingSecurityID).toStringRef (value);
853  }
854 
855  /// Underlying Security ID Source.
857  {
858  return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
859  }
860 
861  /// Closing price of the underlying on the previous day.
862  bool underlyingPrevClosePx (Decimal& price) const
863  {
864  return get (Tags::UnderlyingPrevClosePx).toNumber (price);
865  }
866 
867  /// Instrument Scopes.
869  {
870  return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
871  }
872 
873  /// Related Market Segments.
875  {
876  return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
877  }
878 
879  /// Tick rules.
880  /// The group is absent for buckets, when marketSegmentSubType() is equel to
881  /// MarketSegmentSubType::BTRFBucket
883  {
884  checkSequencePresence("tickRules");
885 
886  return TickRules (getGroup(Tags::NoTickRules) );
887  }
888 
889  /// Price range rules.
890  /// The group is absent for buckets, when marketSegmentSubType() is equel to
891  /// MarketSegmentSubType::BTRFBucket
893  {
894  checkSequencePresence("priceRangeRules");
895  return PriceRangeRules (getGroup(Tags::NoPriceRangeRules) );
896  }
897 
898  /// Defines if one sided quotes are allowed
900  {
901  return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
902  }
903 
904  /// Defines if one sided quotes are allowed
906  {
907  return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
908  }
909 
910  /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
911  /// has to be extended to obtain the valid price range during Fast Market
912  bool fastMarketPercentage (Decimal& value) const
913  {
914  return get (Tags::FastMarketPercentage).toNumber (value);
915  }
916 
917  /// Quote size rules.
919  {
920  return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
921  }
922 
923  /// Flex rules.
925  {
926  return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
927  }
928 
929  /// Match rules.
931  {
932  return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
933  }
934 
935  /// Match rules.
936  /// The group is absent for buckets, when marketSegmentSubType() is equel to
937  /// MarketSegmentSubType::BTRFBucket
939  {
940  checkSequencePresence("matchRules");
941  return MatchRules (getGroup(Tags::NoMatchRules) );
942  }
943 
944  /// Feeds
945  /// The group is absent for buckets, when marketSegmentSubType() is equel to
946  /// MarketSegmentSubType::BTRFBucket
947  Feeds feeds() const
948  {
949  checkSequencePresence("feeds");
950  return Feeds (getGroup(Tags::NoMDFeedTypes) );
951  }
952 
953  private:
955 
956  ProductSnapshot (const void* impl)
957  : Message (impl)
958  {
959  }
960 
961  void checkSequencePresence(const char* seqName) const
962  {
963  if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket)
964  {
965  const std::string enhancedName =
966  std::string("Rdi ProductSnapshot::") + seqName;
967 
968  throw OperationException(
969  enhancedName.c_str(), "The sequence is absent for BTRFBucket subtype");
970  }
971  }
972  };
973  }
974  }
975 }
StringRef marketId() const
Market Identifier Code as specified in ISO 10383.
const Tag EffectiveBusinessDate
Definition: Tags.h:215
SecurityType::Enum securityType() const
Type of security.
InstrumentScopeOperator::Enum instrumentScopeOperator() const
Instrument scope operator.
const Tag QuoteSideModelType
Definition: Tags.h:264
MatchAlgorithm::Enum matchAlgorithm() const
Defines the matching algorithm.
const Tag MatchRuleProductComplex
Definition: Tags.h:156
StringRef mdPrimaryFeedLineID() const
IP Address for Service A.
const Tag UnderlyingSecurityID
Definition: Tags.h:174
const Tag UnderlyingPrevClosePx
Definition: Tags.h:168
Exposes list of available market segment types.
InstrumentType::Enum priceRangeProductComplex() const
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:128
const Tag MarketSegmentSubType
Definition: Tags.h:218
Tick rule scope definitions.
bool parentMktSegmID(StringRef &id) const
Standard Eurex product types.
Exposes list of available market segment subtypes.
const Tag StartTickPriceRange
Definition: Tags.h:108
Decimal endTickPriceRange() const
Ending price range for the specified tick increment (noninclusive).
const Tag MarketSegmentStatus
Definition: Tags.h:137
const Tag ClosedBookIndicator
Definition: Tags.h:225
Exposes list of available Quote side indicators.
const Tag PrimaryServiceLocationID
Definition: Tags.h:133
const Tag SecondaryServiceLocationSubID
Definition: Tags.h:136
QuoteSideModelType::Enum quoteSideModelType() const
Defines if one sided quotes are allowed.
const Tag SecondaryServiceLocationID
Definition: Tags.h:135
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.
MarketSegmentId marketSegmentId() const
Product identifier.
TickRuleScopes tickRuleScopes() const
Tick rule scope definitions.
const Tag MarketDepthTimeInterval
Definition: Tags.h:169
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.
Defines all the months in the year.
Definition: Timestamp.h:31
MarketSegmentSubType::Enum marketSegmentSubType() const
Market Segment subtype.
AuctionType::Enum auctionType() const
Defines the type of auction.
Decimal startPriceRange() const
Start of price range (inclusive).
MarketSegmentStatus::Enum marketSegmentStatus() const
Defines the TES security status.
const Tag FlexProductEligibilityIndicator
Definition: Tags.h:113
const Tag QuoteSideIndicator
Definition: Tags.h:220
const Tag InstrumentScopeSecurityType
Definition: Tags.h:199
const Tag MarketImbalanceIndicator
Definition: Tags.h:226
Exposes list of available quote side model types.
const Tag NextEffectiveBusinessDate
Definition: Tags.h:216
unsigned int UInt32
Definition: Numeric.h:41
bool underlyingSecurityExchange(StringRef &value) const
Market Identifier Code of the underlying as specified in ISO 10383.
Exposes list of available market segment relationship types.
Definition: Defines.h:30
Decimal type for better precision.
Definition: Numeric.h:63
Exposes list of available match types.
MarketSegmentType::Enum marketSegmentType() const
Market Segmen type.
bool instrumentScopeSecuritySubType(UInt32 &value) const
Standard strategy type for complex instruments.
const Tag TickRuleProductComplex
Definition: Tags.h:155
bool underlyingSecurityId(StringRef &value) const
ISIN code of the underlying.
const Tag NoRelatedMarketSegments
Definition: Tags.h:194
Exposes list of available market imbalance indicators.
bool mdRecoveryTimeInterval(UInt32 &interval) const
Recovery interval (duration of one cycle).
Exposes list of available match algorithms.
UInt32 priceRangeRuleID() const
Table identifier, not unique within repeating group.
Decimal startTickPriceRange() const
Starting price range for specified tick increment (inclusive).
bool priceRangeValue(Decimal &value) const
Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is ab...
bool marketDepth(UInt32 &depth) const
Maximum number of price levels for the product.
UInt32 relatedMarketSegmentID() const
Market segment identifier.
bool priceRangePercentage(Decimal &percentage) const
Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absen...
const Tag MDRecoveryTimeInterval
Definition: Tags.h:170
const Tag PrimaryServiceLocationSubID
Definition: Tags.h:134
RelatedMarketSegments relatedMarketSegments() const
Related Market Segments.
InstrumentType::Enum tickRuleProductComplex() const
Defines the instrument type for the tick rule.
bool minBidSize(Decimal &size) const
Minimum bid quantity (identical to minimum offer quantity).
StringRef currency() const
Currency as published in ISO 4217.
const Tag PriceRangePercentage
Definition: Tags.h:143
bool usFirmFlag(bool &flag) const
Flag to identify whether product may be traded from the USA.
const Tag UnderlyingSecurityIDSource
Definition: Tags.h:172
Exposes list of available closed book indicators.
QuoteSideIndicator::Enum quoteSideIndicator() const
Defines if one sided quotes are allowed.
const Tag FastMarketPercentage
Definition: Tags.h:221
const Tag InstrumentScopeOperator
Definition: Tags.h:198
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:161
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:196
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
Exposes list of available auction types.
const Tag PriceRangeProductComplex
Definition: Tags.h:144
UInt32 nextEffectiveBusinessDate() const
Next business date.
const Tag RelatedMarketSegmentID
Definition: Tags.h:195
Decimal endPriceRange() const
End of price range (non-inclusive).
const Tag InstrumentScopeSecuritySubType
Definition: Tags.h:200
const Tag FastMarketIndicator
Definition: Tags.h:159
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.
QuoteSizeRules quoteSizeRules() const
Quote size rules.
bool mdSecondaryFeedLineID(StringRef &id) const
IP Address for Service B.
const Tag NoInstrumentScopes
Definition: Tags.h:197
Exposes list of available feed types.
InstrumentType::Enum flexProductEligibilityComplex() const
Defines the strategy types available for user defined strategies.
BookType::Enum mdBookType() const
Book type.
bool underlyingSecurityIdSource(StringRef &value) const
Underlying Security ID Source.
PartitionId partitionId() const
Partition of the product.
const Tag FlexProductEligibilityComplex
Definition: Tags.h:162
bool marketSegmentDesc(StringRef &desc) const
Product Description.
const Tag NoAuctionTypeRules
Definition: Tags.h:222
bool flexProductEligibilityIndicator() const
Defines if user defined strategies are allowed.
const Tag UnderlyingSecurityExchange
Definition: Tags.h:173
MatchType::Enum matchType() const