OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  16.1.3
API documentation
Defines.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 
22 #include <string>
23 
29 
30 namespace OnixS
31 {
32  namespace Eurex
33  {
34  namespace MarketData
35  {
36  /// Alias for Market Segment type (Product name).
37  typedef std::string MarketSegment;
38 
39  /// Alias for Market Segment ID type.
41 
42  /// Alias for Market depth type.
44 
45  const MarketSegmentId UndefinedMarketSegmentId = 0;
46 
47  /// Alias for Partition ID type.
49 
50  /// Alias for Security Id type.
51  typedef Int64 SecurityId;
52 
53  /// Alias for Quantity type.
54  typedef UInt64 Quantity;
55 
56  /// Feed types based on type of market data service.
57  struct NetFeedType
58  {
59  /// Integral base type of enumeration.
60  typedef char Base;
61 
62  /// Feed types based on type of market data service.
63  enum Enum
64  {
65  /// Incremental/real-time.
67 
68  /// Market recovery for MBP (Market By Price) books.
70  };
71  };
72 
73  /// Feed roles (primary, secondary).
74  struct NetFeedRole
75  {
76  /// Integral base type of enumeration.
77  typedef char Base;
78 
79  /// List of known feed roles.
80  enum Enum
81  {
82  /// Origin is unknown or lost
84 
85  /// FeedA
87 
88  /// FeedB
89  FeedB
90  };
91  };
92 
93  struct DataSource
94  {
95  /// Time when the packet was received by Handler from UDP, in system ticks, @see Time.h
97 
98  /// Time when the packet was originally received by Handler from UDP
99  /// Valid only for backtesting
101 
102  /// Packet sequence number
104 
105  /// Packet message number
107 
108  /// Indicates whether a message is last in the packet
110 
111  /// Time when market data feed handler writes packet on the wire.
112  UInt64 sendingTime;
113 
114  /// Current load of system.
115  ///
116  /// @note Time difference between the incoming ETS-order/quote
117  /// and the time the market data is written to the socket. This
118  /// information is provided for the incremental feed of Eurex EMDI only.
120 
121  /// Unique id for a sender.
123 
124  /// Sending partition.
125  ///
126  /// @note For EMDI feed messages only.
127  PartitionId partitionId;
128 
129  /// Product identifier
130  ///
131  /// @note For EOBI feed messages only.
132  MarketSegmentId marketSegmentId;
133 
134  /// An indicator whether the atomic unit of work fits into one datagram
135  ///
136  /// @note For EOBI feed messages only.
138 
139  /// An origin of the packet
141  Origin origin;
142 
143  ///
144  bool cached;
145  };
146 
147  /// Exposes list of leg sides
148  struct ONIXS_EUREX_EMDI_API LegSide
149  {
150  enum Enum
151  {
152  /// Used to identify absence of value.
153  Undefined = -1,
154 
155  /// Buy
156  Buy = 1,
157 
158  /// Sell
159  Sell = 2,
160  };
161  };
162 
163  /// Exposes list of available security statuses
164  struct ONIXS_EUREX_EMDI_API SecurityStatus
165  {
166  enum Enum
167  {
168  /// Used to identify absence of value.
169  Undefined = -1,
170 
171  /// Defines if product is traded on on NTA.
172  Active = 0,
173 
174  /// Inactive
175  Inactive = 1,
176 
177  /// Expired
178  Expired = 2,
179 
180  ///
181  KnockedOut = 3,
182 
183  ///
184  KnockOutRevoked = 4,
185 
186  /// Suspended
187  Suspended = 5,
188 
189  /// Defines if product is still traded on "Eurex classic"
190  Published = 6,
191 
192  ///
193  PendingDeletion = 7,
194 
195  ///
196  KnockedOutAndSuspended = 8,
197 
198  };
199  };
200 
201  /// Exposes list of available trade session statuses.
202  struct ONIXS_EUREX_EMDI_API TradSesStatus
203  {
204  enum Enum
205  {
206  /// Used to identify absence of value.
207  Undefined = -1,
208 
209  ///
210  Halted = 0,
211 
212  ///
213  Open = 1,
214 
215  ///
216  Closed = 2,
217 
218  ///
219  PreClose = 3,
220  };
221  };
222 
223 
224  struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator
225  {
226  enum Enum
227  {
228  /// Used to identify absence of value.
229  Undefined = -1,
230 
231  /// Not implied
232  NotImplied = 0,
233 
234  /// Both implied in and implied out
235  BothImpliedInAndImpliedOut = 1,
236  };
237  };
238 
239  /// Exposes list of available entry types
240  struct ONIXS_EUREX_EMDI_API MDEntryType
241  {
242  enum Enum
243  {
244  /// Used to identify absence of value.
245  Undefined = -1,
246 
247  /// Bid
248  Bid = 0,
249 
250  /// Offer
251  Offer = 1,
252 
253  /// Trade
254  Trade = 2,
255 
256  /// Empty book
257  EmptyBook = 3,
258 
259  /// Auction clearing price
260  AuctionClearingPrice = 4,
261 
262  /// Settlement Price
263  SettlementPrice = 5,
264 
265  /// Open Interest
267 
268  ///Trade Volume
269  TradeVolume = 7,
270 
271  ///Market Bid
272  MarketBid = 8,
273 
274  ///Market Offer
275  MarketOffer = 9,
276 
277  ///Imbalance
278  Imbalance = 10,
279  };
280  };
281 
282  struct ONIXS_EUREX_EMDI_API QuoteCondition
283  {
284  enum Enum
285  {
286  /// Used to identify absence of value.
287  Undefined = -1,
288 
289  // Crossed,
290  Crossed = 0,
291 
292  // OrderImbalance,
293  OrderImbalance = 1,
294  };
295  };
296 
297  /// Exposes list of available trade types
298  struct ONIXS_EUREX_EMDI_API TrdType
299  {
300  // The trade type enum entries do not use numeric values
301  // mentioned in documentation. Instead they are identified by
302  // ordinal (starting from zero) preserving the order in the doc.
303 
304  enum Enum
305  {
306  /// Used to identify absence of value.
307  Undefined = -1,
308 
309  /// Regular Trade
310  RegularTrade = 0,
311 
312  /// Block trade
314 
315  /// Exchange for Physical
317 
318  /// Exchange for swap
320 
321  ///
323 
324  /// Exchange basis facility
326 
327  /// Vola trade
329 
330  /// Exchange for Physical Fin trade
332 
333  /// EFPIndexFutures trade
335 
336  ///
338 
339  ///
341 
342  ///
344 
345  ///
347 
348  /// Opening auction trade
350 
351  /// Intraday auction trade
353 
354  /// Volatility auction trade
356 
357  /// Closing auction trade
359 
360  /// Cross auction trade
362 
363  ///
365 
366  ///
367  LiquidityImprovementCross
368  };
369 
370  static std::string toString (Enum value);
371  };
372 
373  /// Exposes list of available trading session IDs
374  struct ONIXS_EUREX_EMDI_API TradingSessionId
375  {
376  enum Enum
377  {
378  /// Used to identify absence of value.
379  Undefined = -1,
380 
381  /// Day
382  Day = 0,
383 
384  /// Morning
385  Morning = 1,
386 
387  /// Evening
388  Evening = 2,
389 
390  /// After-Hours
391  AfterHours = 3,
392 
393  /// Holiday
394  Holiday = 4,
395  };
396  };
397 
398  /// Exposes list of available trading session sub IDs
399  struct ONIXS_EUREX_EMDI_API TradingSessionSubID
400  {
401  enum Enum
402  {
403  /// Used to identify absence of value.
404  Undefined = -1,
405 
406  /// PreTrading
407  PreTrading = 0,
408 
409  /// Continuous
410  Continuous = 1,
411 
412  /// Closing
413  Closing = 2,
414 
415  /// PostTrading
416  PostTrading = 3,
417 
418  /// ScheduledIntradayAuction
419  ScheduledIntradayAuction = 4,
420 
421  /// Quiescent
422  Quiescent = 5,
423 
424  /// AnyAuction
425  AnyAuction = 6,
426 
427  /// ContinuousAuctionIssuer
428  ContinuousAuctionIssuer = 7,
429 
430  /// ContinuousAuctionSpecialist
431  ContinuousAuctionSpecialist
432  };
433  };
434 
435  /// Exposes list of available security trading statuses
436  struct ONIXS_EUREX_EMDI_API SecurityTradingStatus
437  {
438  enum Enum
439  {
440  /// Used to identify absence of value.
441  Undefined = -1,
442 
443  /// Trading Halt
444  TradingHalt = 0,
445 
446  /// Closed
447  Closed = 1,
448 
449  /// Restricted
450  Restricted = 2,
451 
452  /// Book
453  Book = 3,
454 
455  /// Continuous
456  Continuous = 4,
457 
458  /// Opening auction
459  OpeningAuction = 5,
460 
461  /// Opening auction freeze
462  OpeningAuctionFreeze = 6,
463 
464  /// Intraday auction
465  IntradayAuction = 7,
466 
467  /// Intraday auction freeze
468  IntradayAuctionFreeze = 8,
469 
470  /// Circuit breaker auction
471  CircuitBreakerAuction = 9,
472 
473  /// Circuit breaker auction freeze
474  CircuitBreakerAuctionFreeze = 10,
475 
476  /// Closing auction
477  ClosingAuction = 11,
478 
479  /// Closing auction freeze
480  ClosingAuctionFreeze = 12,
481 
482  /// CIPO Auction
483  IPOAuction = 13,
484 
485  /// IPO Auction Freeze
486  IPOAuctionFreeze = 14,
487 
488  ///
490 
491  ///
493 
494  ///
496 
497  ///
499 
500  ///
502 
503  ///
504  CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze
505  };
506  };
507 
508 
509  struct ONIXS_EUREX_EMDI_API SecurityTradingEvent
510  {
511  enum Enum
512  {
513  /// Used to identify absence of value.
514  Undefined = -1,
515 
516  ///
517  None = 0,
518 
519  ///
520  PriceVolatilityAuctionIsExtended = 1,
521 
522  ///
523  PriceVolatilityAuctionIsExtendedAgain = 2,
524  };
525  };
526 
527  /// Exposes list of available trade conditions
528  struct ONIXS_EUREX_EMDI_API TradeCondition
529  {
530  enum Enum
531  {
532  /// Used to identify absence of value.
533  Undefined = 0,
534 
535  /// Exchange last
536  ExchangeLast = 1,
537 
538  /// Opening price
539  OpeningPrice = 2,
540 
541  /// High price
542  HighPrice = 4,
543 
544  /// Low price
545  LowPrice = 8,
546 
547  /// Official closing price
548  OfficialClosingPrice = 16,
549 
550  /// Last auction price
551  LastAuctionPrice = 32,
552 
553  /// Out of sequence ETH
554  OutOfSequenceETH = 64,
555 
556  /// Previous Closing Price
557  PreviousClosingPrice = 128,
558 
559  /// Volume Only
560  VolumeOnly = 256,
561 
562  ///
563  TradingOnTermsOfIssue = 512,
564 
565  ///
566  SpecialAuction = 1024,
567 
568  ///
569  TradeAtClose = 2048,
570 
571  ///
572  Retail = 4096
573  };
574  };
575 
576  struct ONIXS_EUREX_EMDI_API TradeConditionSet
577  {
578  explicit
579  TradeConditionSet (UInt64 value)
580  : value_ (value)
581  {}
582 
583  bool contain (TradeCondition::Enum value) const
584  {
585  return (value_ & value) != 0;
586  }
587 
588  bool containExchangeLast() const
589  {
590  return contain (TradeCondition::ExchangeLast);
591  }
592  bool containOpeningPrice() const
593  {
594  return contain (TradeCondition::OpeningPrice);
595  }
596  bool containHighPrice() const
597  {
598  return contain (TradeCondition::HighPrice);
599  }
600  bool containLowPrice() const
601  {
602  return contain (TradeCondition::LowPrice);
603  }
605  {
606  return contain (TradeCondition::OfficialClosingPrice);
607  }
609  {
610  return contain (TradeCondition::LastAuctionPrice);
611  }
613  {
614  return contain (TradeCondition::OutOfSequenceETH);
615  }
617  {
618  return contain (TradeCondition::PreviousClosingPrice);
619  }
620  bool containVolumeOnly() const
621  {
622  return contain (TradeCondition::VolumeOnly);
623  }
624  bool containRetail() const
625  {
626  return contain (TradeCondition::Retail);
627  }
629  {
631  }
633  {
634  return contain (TradeCondition::SpecialAuction);
635  }
636  bool containTradeAtClose() const
637  {
638  return contain(TradeCondition::TradeAtClose);
639  }
640 
641  std::string toString() const;
642 
643  private:
644  UInt64 value_;
645  };
646 
647  /// Exposes list of available origin types
648  struct ONIXS_EUREX_EMDI_API MDOriginType
649  {
650  enum Enum
651  {
652  /// Used to identify absence of value.
653  Undefined = -1,
654 
655  ///
656  Book = 0,
657 
658  ///
659  OffBook = 1,
660  };
661  };
662 
663  /// Exposes list of available update actions
664  struct ONIXS_EUREX_EMDI_API MDUpdateAction
665  {
666  enum Enum
667  {
668  /// Used to identify absence of value.
669  Undefined = -1,
670 
671  /// New
672  New = 0,
673 
674  /// Change
675  Change = 1,
676 
677  /// Delete
678  Delete = 2,
679 
680  /// DeleteThru
681  DeleteThru = 3,
682 
683  /// DeleteFrom
684  DeleteFrom = 4,
685 
686  /// Overlay
687  Overlay = 5
688  };
689  };
690 
691  /// Exposes list of available aggressor sides
692  struct ONIXS_EUREX_EMDI_API Side
693  {
694  enum Enum
695  {
696  /// Used to identify absence of value.
697  Undefined = -1,
698 
699  /// Buy
700  Buy = 1,
701 
702  /// Sell
703  Sell = 2,
704  };
705  };
706 
707  /// Exposes list of available market segment statuses.
708  struct ONIXS_EUREX_EMDI_API MarketSegmentStatus
709  {
710  enum Enum
711  {
712  /// Used to identify absence of value.
713  Undefined = -1,
714 
715  /// Defines if product is traded on on NTA.
716  Active = 0,
717 
718  /// Inactive
719  Inactive = 1,
720 
721  /// Defines if product is still traded on "Eurex classic"
722  Published = 2,
723  };
724  };
725 
726  /// Exposes list of available instrument types for tick rule.
727  struct ONIXS_EUREX_EMDI_API InstrumentType
728  {
729  enum Enum
730  {
731  /// Used to identify absence of value.
732  Undefined = -1,
733 
734  /// Simple instrument
735  SimpleInstrument = 1,
736 
737  /// Standard option strategy
738  StandardOptionStrategy = 2,
739 
740  /// Non standard option strategy
741  NonStandardOptionStrategy = 3,
742 
743  /// Volatility strategy
744  VolatilityStrategy = 4,
745 
746  /// Futures spread
747  FuturesSpread = 5,
748 
749  /// Inter Product Spread
750  InterProductSpread = 6,
751 
752  /// Standard Futures Strategy
753  StandardFuturesStrategy = 7,
754 
755  /// Pack And Bundle
756  PackAndBundle = 8,
757 
758  /// Strip
759  Strip = 9,
760 
761  /// Flexible
762  Flexible = 10,
763 
764  /// Commodity Strips
765  CommodityStrips = 11,
766 
767  /// Scaled Simple Instrument
768  ScaledSimpleInstrument = 12,
769 
770  /// Non Standard Volatility Strategy
771  NonStandardVolatilityStrategy = 13
772  };
773  };
774 
775  /// Exposes list of available book types.
776  struct ONIXS_EUREX_EMDI_API BookType
777  {
778  enum Enum
779  {
780  /// Used to identify absence of value.
781  Undefined = -1,
782 
783  /// Top Of Book
784  TopOfBook = 0,
785 
786  /// Price Depth
787  PriceDepth = 1,
788 
789  /// Order Depth
790  OrderDepth = 2,
791  };
792  };
793 
794  /// Exposes list of available sub book types.
795  struct ONIXS_EUREX_EMDI_API SubBookType
796  {
797  enum Enum
798  {
799  /// Used to identify absence of value.
800  Undefined = -1,
801 
802  /// Price Depth
803  IPSImpliedVolumeWithoutQuantityRestriction = 0,
804 
805  /// Order Depth
806  IPSImpliedVolumeWithQuantityRestriction = 1,
807  };
808  };
809 
810  /// Indicator for stressed market conditions.
811  struct ONIXS_EUREX_EMDI_API MarketCondition
812  {
813  enum Enum
814  {
815  /// Used to identify absence of value.
816  Undefined = -1,
817 
818  /// Normal
819  Normal = 0,
820 
821  /// Stressed
822  Stressed = 1
823  };
824  };
825 
826  /// A trade has to be flagged as "algorithmic", if at least one of the
827  /// matched orders was submitted by a trading algorithm.Applicable
828  /// for cash market products only.
829  struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator
830  {
831  enum Enum
832  {
833  /// Used to identify absence of value.
834  Undefined = -1,
835 
836  /// Algorithmic Trade
837  AlgorithmicTrade = 1
838  };
839  };
840 
841  /// MultiLegReportingType
842  struct ONIXS_EUREX_EMDI_API MultiLegReportingType
843  {
844  enum Enum
845  {
846  /// Used to identify absence of value.
847  Undefined = -1,
848 
849  /// Single Security
850  SingleSecurity = 1,
851 
852  /// Individual Leg Of A MultiLeg Security
853  IndividualLegOfMultiLegSecurity = 2,
854 
855  /// Multi Leg Security
856  MultiLegSecurity = 3
857  };
858  };
859 
860  /// MultiLegPriceModel
861  struct ONIXS_EUREX_EMDI_API MultiLegPriceModel
862  {
863  enum Enum
864  {
865  /// Used to identify absence of value.
866  Undefined = -1,
867 
868  /// Standard
869  Standard = 0,
870 
871  /// User Defined
872  UserDefined = 2
873  };
874  };
875 
876 
877  /// Exposes list of available sold out indicators.
878  struct ONIXS_EUREX_EMDI_API SoldOutIndicator
879  {
880  enum Enum
881  {
882  /// Used to identify absence of value.
883  Undefined = -1,
884 
885  ///
886  SoldOut = 1,
887  };
888  };
889 
890  ///
891  struct ONIXS_EUREX_EMDI_API LastFragment
892  {
893  enum Enum
894  {
895  /// Used to identify absence of value.
896  Undefined = -1,
897 
898  /// NotLastMessage
899  NotLastMessage = 0,
900 
901  /// LastMessage
903  };
904  };
905 
906  namespace EOBI
907  {
908  /// Alias for Quantity Type
909  /// Quantity in integer format including 4 decimals.
910  typedef Int64 QuantityType;
911 
912  struct ONIXS_EUREX_EMDI_API AggressorSide // UInt8
913  {
914  enum Enum
915  {
916  /// Used to identify absence of value
917  NoValue = 0xFF,
918 
919  /// Triggered by the buy side
920  Buy = 1,
921 
922  /// Triggered by the sell side
923  Sell = 2,
924  };
925 
926  static std::string toString (Enum value);
927  };
928 
929  struct ONIXS_EUREX_EMDI_API ApplSeqResetIndicator // UInt8
930  {
931  enum Enum
932  {
933  NoValue = 0xFF,
934  NoReset = 0,
935  Reset = 1,
936  };
937 
938  static std::string toString (Enum value);
939  };
940 
941  struct ONIXS_EUREX_EMDI_API CompletionIndicator // UInt8
942  {
943  enum Enum
944  {
945  NoValue = 0xFF,
946  Incomplete = 0,
947  Complete = 1,
948  };
949 
950  static std::string toString (Enum value);
951  };
952 
953  struct ONIXS_EUREX_EMDI_API FastMarketIndicator // UInt8
954  {
955  enum Enum
956  {
957  NoValue = 0xFF,
958  No = 0,
959  Yes = 1,
960  };
961 
962  static std::string toString (Enum value);
963  };
964 
965  struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator // UInt8
966  {
967  enum Enum
968  {
969  NoValue = 0xFF,
970  NotImplied = 0,
971  ImpliedInOut = 3,
972  };
973 
974  static std::string toString (Enum value);
975  };
976 
977  struct ONIXS_EUREX_EMDI_API LegSecurityIDSource // String(1)
978  {
979  enum Enum
980  {
981  NoValue = 0,
982  Marketplace = 'M',
983  };
984 
985  static std::string toString (Enum value);
986  };
987 
988  struct ONIXS_EUREX_EMDI_API LegSide // UInt8
989  {
990  enum Enum
991  {
992  NoValue = 0xFF,
993  Buy = 1,
994  Sell = 2,
995  };
996 
997  static std::string toString (Enum value);
998  };
999 
1000  struct ONIXS_EUREX_EMDI_API MDEntryType // UInt8
1001  {
1002  enum Enum
1003  {
1004  NoValue = 0xFF,
1005  Trade = 2,
1006  OpeningPrice = 4,
1007  ClosingPrice = 5,
1008  HighPrice = 7,
1009  LowPrice = 8,
1010  TradeVolume = 66,
1011  PreviousClosingPrice = 101,
1012  OpeningAuction = 200,
1013  IntradayAuction = 201,
1014  CircuitBreakerAuction = 202,
1015  ClosingAuction = 203,
1016  IPOAuction = 204,
1017  };
1018 
1019  static std::string toString (Enum value);
1020  };
1021 
1022  struct ONIXS_EUREX_EMDI_API MDReportEvent // UInt8
1023  {
1024  enum Enum
1025  {
1026  NoValue = 0xFF,
1027  ScopeDefinition = 0,
1028  };
1029  };
1030 
1031  struct ONIXS_EUREX_EMDI_API MDUpdateAction // UInt8
1032  {
1033  enum Enum
1034  {
1035  NoValue = 0xFF,
1036  New = 0,
1037  Change = 1,
1038  Delete = 2,
1039  Overlay = 5,
1040  };
1041  };
1042 
1043  struct ONIXS_EUREX_EMDI_API MarketDataType // UInt8
1044  {
1045  enum Enum
1046  {
1047  NoValue = 0xFF,
1048  OrderBookMaintenance = 1,
1049  OrderBookExecution = 2,
1052  AuctionBBO = 5,
1054  CrossTradeAnnouncement = 7,
1056  MarketSegmentSnapshot = 9,
1057  SingleInstrumentSnapshot = 10,
1058  OrderBookSnapshot = 11,
1059  MatchEvent = 12,
1061 
1062  ComplexInstrument = 14,
1063  TesTradeReport = 15,
1064  HhIndex = 16,
1065  FlexibleInstrument = 17,
1066  };
1067  };
1068 
1069  struct ONIXS_EUREX_EMDI_API MatchSubType // UInt8
1070  {
1071  enum Enum
1072  {
1073  NoValue = 0xFF,
1074  OpeningAuction = 1,
1075  ClosingAuction = 2,
1076  IntradayAuction = 3,
1077  CircuitBreakerAuction = 4,
1078  IPOAuction = 5,
1079  };
1080 
1081  static std::string toString (Enum value);
1082  };
1083 
1084  struct ONIXS_EUREX_EMDI_API MatchType // UInt8
1085  {
1086  enum Enum
1087  {
1088  NoValue = 0xFF,
1089  Manual = 3,
1090  Uncrossing = 5,
1091  Auction = 7,
1092  LiquidityImprovementCross = 13,
1093  ContinuousAuction = 14
1094  };
1095 
1096  static std::string toString (Enum value);
1097  };
1098 
1099  struct ONIXS_EUREX_EMDI_API NoMarketSegments // UInt8
1100  {
1101  enum Enum
1102  {
1103  NoValue = 0xFF,
1104  One = 1,
1105  };
1106 
1107  static std::string toString (Enum value);
1108  };
1109 
1110  struct ONIXS_EUREX_EMDI_API ProductComplex // UInt8
1111  {
1112  enum Enum
1113  {
1114  NoValue = 0xFF,
1115 
1116  SimpleInstrument = 1,
1117  StandardOptionStrategy = 2,
1118  NonStandardOptionStrategy = 3,
1119  VolatilityStrategy = 4,
1120  FuturesSpread = 5,
1121  InterProductSpread = 6,
1122  StandardFuturesStrategy = 7,
1123  PackAndBundle = 8,
1124  Strip = 9,
1125  FlexibleInstrument = 10,
1126  CommodityStrip = 11,
1127  ScaledSimpleInstrument = 12,
1128  NonStandardVolatilityStrategy = 13
1129  };
1130 
1131  static std::string toString (Enum value);
1132  };
1133 
1134  struct ONIXS_EUREX_EMDI_API SecurityIDSource // String(1)
1135  {
1136  enum Enum
1137  {
1138  NoValue = 0,
1139  Marketplace = 'M',
1140  };
1141 
1142  static std::string toString (Enum value);
1143  };
1144 
1145  struct ONIXS_EUREX_EMDI_API SecurityStatus // UInt8
1146  {
1147  enum Enum
1148  {
1149  NoValue = 0xFF,
1150  Active = 1,
1151  Inactive = 2,
1152  Expired = 4,
1153  KnockedOut = 6,
1154  KnockOutRevoked = 7,
1155  Suspended = 9,
1156  PendingDeletion = 11,
1157  KnockedOutAndSuspended = 12,
1158  };
1159 
1160  static std::string toString (Enum value);
1161  };
1162 
1163  struct ONIXS_EUREX_EMDI_API SecurityTradingStatus // UInt8
1164  {
1165  enum Enum
1166  {
1167  NoValue = 0xFF,
1168 
1169  TradingHalt = 2,
1170  MarketImbalanceBuy = 7,
1171  MarketImbalanceSell = 8,
1172  Closed = 200,
1173  Restricted = 201,
1174  Book = 202,
1175  Continuous = 203,
1176  OpeningAuction = 204,
1177  OpeningAuctionFreeze = 205,
1178  IntradayAuction = 206,
1179  IntradayAuctionFreeze = 207,
1180  CircuitBreakerAuction = 208,
1181  CircuitBreakerAuctionFreeze = 209,
1182  ClosingAuction = 210,
1183  ClosingAuctionFreeze = 211,
1184  IPOAuction = 212,
1185  IPOAuctionFreeze = 213,
1186  PreCall = 214,
1187  Call = 215,
1188  Freeze = 216,
1189  TradeAtClose = 217,
1190  CircuitBreakerAuctionTriggeredByStaticLimitBreach = 220,
1191  CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze = 221
1192  };
1193 
1194  static std::string toString (Enum value);
1195  };
1196 
1197  struct ONIXS_EUREX_EMDI_API SecurityType // String(4)
1198  {
1199  enum Enum
1200  {
1201  NoValue = 0,
1202  Option = 1, // OPT,
1203  Future = 2, // FUT,
1204  MultiLeg = 3 // MLEG,
1205  };
1206 
1207  static std::string toString (Enum value);
1208  };
1209 
1210  struct ONIXS_EUREX_EMDI_API SecurityUpdateAction // String(1)
1211  {
1212  enum Enum
1213  {
1214  NoValue = 0,
1215  Add = 'A',
1216  Delete = 'D',
1217  };
1218 
1219  static std::string toString (Enum value);
1220  };
1221 
1222  struct ONIXS_EUREX_EMDI_API Side // UInt8
1223  {
1224  enum Enum
1225  {
1226  NoValue = 0xFF,
1227  Buy = 1,
1228  Sell = 2,
1229  };
1230 
1231  static std::string toString (Enum value);
1232  };
1233 
1234  /// Indicates whether a synthetic match is occurred.
1235  struct ONIXS_EUREX_EMDI_API TradeCondition // UInt16
1236  {
1237  enum Enum
1238  {
1239  NoValue = 0xFFFF,
1240  ImpliedTrade = 1,
1241  OutOfSequence = 107,
1242  MidpointPrice = 155,
1243  TradingOnTermsOfIssue = 156,
1244  SpetialAuction = 596,
1245  TradeAtClose = 624,
1246  Retail = 743
1247  };
1248 
1249  static std::string toString (Enum value);
1250  };
1251 
1252  struct ONIXS_EUREX_EMDI_API TradSesEvent // UInt8
1253  {
1254  enum Enum
1255  {
1256  NoValue = 0xFF,
1257  TBD = 0,
1258  StatusChange = 3,
1259  };
1260 
1261  static std::string toString (Enum value);
1262  };
1263 
1264  struct ONIXS_EUREX_EMDI_API TradSesStatus // UInt8
1265  {
1266  enum Enum
1267  {
1268  NoValue = 0xFF,
1269  Halted = 1,
1270  Open = 2,
1271  Closed = 3,
1272  };
1273 
1274  static std::string toString (Enum value);
1275  };
1276 
1277  struct ONIXS_EUREX_EMDI_API TradingSessionID // UInt8
1278  {
1279  enum Enum
1280  {
1281  NoValue = 0xFF,
1282  Day = 1,
1283  Morning = 3,
1284  Evening = 5,
1285  AfterHours = 6,
1286  Holiday = 7,
1287  };
1288 
1289  static std::string toString (Enum value);
1290  };
1291 
1292  struct ONIXS_EUREX_EMDI_API TradingSessionSubID // UInt8
1293  {
1294  enum Enum
1295  {
1296  NoValue = 0xFF,
1297  PreTrading = 1,
1298  Continuous = 3,
1299  Closing = 4,
1300  PostTrading = 5,
1301  Quiescent = 7,
1302  };
1303 
1304  static std::string toString (Enum value);
1305  };
1306 
1307 
1308  struct ONIXS_EUREX_EMDI_API PotentialSecurityTradingEvent // UInt8
1309  {
1310  enum Enum
1311  {
1312  NoValue = 0xFF,
1313 
1314  /// None
1315  None = 0,
1316 
1317  /// Price volatility, auction is extended
1318  PriceVolatilityAuctionIsExtended = 10,
1319  };
1320 
1321  static std::string toString (Enum value);
1322  };
1323 
1324  struct ONIXS_EUREX_EMDI_API OrdType // UInt8
1325  {
1326  enum Enum
1327  {
1328  NoValue = 0xFF,
1329 
1330  /// Market Order
1331  MarketOrder = 1,
1332  };
1333 
1334  static std::string toString(Enum value);
1335  };
1336 
1337  struct ONIXS_EUREX_EMDI_API SecurityTradingEvent // UInt8
1338  {
1339  enum Enum
1340  {
1341  NoValue = 0xFF,
1342 
1343  /// Price volatility, auction is extended
1344  PriceVolatilityAuctionIsExtended = 10,
1345 
1346  /// Price volatility, auction is extended again
1347  PriceVolatilityAuctionIsExtendedAgain = 11,
1348  };
1349 
1350  static std::string toString (Enum value);
1351  };
1352 
1353  struct ONIXS_EUREX_EMDI_API OrderType // UInt8
1354  {
1355  enum Enum
1356  {
1357  NoValue = 0xFF,
1358 
1359  ///
1360  MarketOrder = 1,
1361  };
1362 
1363  static std::string toString (Enum value);
1364  };
1365 
1366  struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator // UInt8
1367  {
1368  enum Enum
1369  {
1370  NoValue = 0xFF,
1371 
1372  ///
1373  AlgorithmicTrade = 1,
1374  };
1375 
1376  static std::string toString(Enum value);
1377  };
1378 
1379  struct ONIXS_EUREX_EMDI_API MarketCondition // UInt8
1380  {
1381  enum Enum
1382  {
1383  NoValue = 0xFF,
1384 
1385  ///
1386  Normal = 0,
1387 
1388  ///
1389  Stressed = 1
1390  };
1391 
1392  static std::string toString(Enum value);
1393  };
1394 
1395  struct ONIXS_EUREX_EMDI_API LegSecurityType // UInt8
1396  {
1397  enum Enum
1398  {
1399  NoValue = 0xFF,
1400 
1401  ///
1402  LegSecurityMultiLeg = 0,
1403 
1404  ///
1405  LegSecurityUnderlyingLeg = 1
1406  };
1407 
1408  static std::string toString(Enum value);
1409  };
1410 
1411  struct ONIXS_EUREX_EMDI_API SoldOutIndicator // UInt8
1412  {
1413  enum Enum
1414  {
1415  NoValue = 0xFF,
1416 
1417  ///
1418  SoldOut = 1,
1419  };
1420 
1421  static std::string toString(Enum value);
1422  };
1423 
1424  struct ONIXS_EUREX_EMDI_API SecurityMassStatus // UInt8
1425  {
1426  enum Enum
1427  {
1428  NoValue = 0xFF,
1429 
1430  ///
1431  Active = 1,
1432 
1433  ///
1434  Inactive = 2,
1435 
1436  ///
1437  Expired = 4,
1438 
1439  ///
1440  KnockedOut = 6,
1441 
1442  ///
1443  KnockOutRevoked = 7,
1444 
1445  ///
1446  Suspended = 9,
1447 
1448  ///
1449  PendingDeletion = 11,
1450 
1451  ///
1452  KnockedOutAndSuspended = 12
1453  };
1454 
1455  static std::string toString(Enum value);
1456  };
1457 
1458  struct ONIXS_EUREX_EMDI_API SecurityMassTradingStatus // UInt8
1459  {
1460  enum Enum
1461  {
1462  NoValue = 0xFF,
1463 
1464  ///
1465  TradingHalt = 2,
1466 
1467  ///
1468  MarketImbalanceBuy = 7,
1469 
1470  ///
1471  MarketImbalanceSell = 8,
1472 
1473  ///
1474  Closed = 200,
1475 
1476  ///
1477  Restricted = 201,
1478 
1479  ///
1480  Book = 202,
1481 
1482  ///
1483  Continuous = 203,
1484 
1485  ///
1486  OpeningAuction = 204,
1487 
1488  ///
1489  OpeningAuctionFreeze = 205,
1490 
1491  ///
1492  IntradayAuction = 206,
1493 
1494  ///
1495  IntradayAuctionFreeze = 207,
1496 
1497  ///
1498  CircuitBreakerAuction = 208,
1499 
1500  ///
1501  CircuitBreakerAuctionFreeze = 209,
1502 
1503  ///
1504  ClosingAuction = 210,
1505 
1506  ///
1507  ClosingAuctionFreeze = 211,
1508 
1509  ///
1510  IPOAuction = 212,
1511 
1512  ///
1513  IPOAuctionFreeze = 213,
1514 
1515  ///
1516  PreCall = 214,
1517 
1518  ///
1519  Call = 215,
1520 
1521  ///
1522  Freeze = 216,
1523 
1524  ///
1525  TradeAtClose = 217
1526  };
1527 
1528  static std::string toString(Enum value);
1529  };
1530 
1531  struct ONIXS_EUREX_EMDI_API MassMarketCondition // UInt8
1532  {
1533  enum Enum
1534  {
1535  NoValue = 0xFF,
1536 
1537  ///
1538  Normal = 0,
1539 
1540  ///
1541  Stressed = 1
1542  };
1543 
1544  static std::string toString(Enum value);
1545  };
1546 
1547  struct ONIXS_EUREX_EMDI_API SecurityMassTradingEvent // UInt8
1548  {
1549  enum Enum
1550  {
1551  NoValue = 0xFF,
1552 
1553  /// Price volatility, auction is extended
1554  PriceVolatilityAuctionIsExtended = 10,
1555 
1556  /// Price volatility, auction is extended again
1557  PriceVolatilityAuctionIsExtendedAgain = 11
1558  };
1559 
1560  static std::string toString(Enum value);
1561  };
1562 
1563  struct ONIXS_EUREX_EMDI_API MassSoldOutIndicator // UInt8
1564  {
1565  enum Enum
1566  {
1567  NoValue = 0xFF,
1568 
1569  ///
1570  SoldOut = 1,
1571  };
1572 
1573  static std::string toString(Enum value);
1574  };
1575 
1576 
1577  struct ONIXS_EUREX_EMDI_API LastFragment // UInt8
1578  {
1579  enum Enum
1580  {
1581  NoValue = 0xFF,
1582 
1583  ///
1584  N = 0,
1585 
1586  ///
1587  Y = 1,
1588  };
1589 
1590  static std::string toString(Enum value);
1591  };
1592 
1593  struct ONIXS_EUREX_EMDI_API PutOrCall // UInt8
1594  {
1595  enum Enum
1596  {
1597  NoValue = 0xFF,
1598 
1599  ///
1600  Put = 0,
1601 
1602  ///
1603  Call = 1,
1604  };
1605 
1606  static std::string toString(Enum value);
1607  };
1608 
1609  struct ONIXS_EUREX_EMDI_API ExerciseStyle // UInt8
1610  {
1611  enum Enum
1612  {
1613  NoValue = 0xFF,
1614 
1615  ///
1616  European = 0,
1617 
1618  ///
1619  American = 1,
1620  };
1621 
1622  static std::string toString(Enum value);
1623  };
1624 
1625  struct ONIXS_EUREX_EMDI_API SettlMethod // UInt8
1626  {
1627  enum Enum
1628  {
1629  NoValue = 0xFF,
1630 
1631  ///
1632  Cash = 0,
1633 
1634  ///
1635  Physical = 1,
1636  };
1637 
1638  static std::string toString(Enum value);
1639  };
1640 
1641 
1642  struct ONIXS_EUREX_EMDI_API TrdType // UInt16
1643  {
1644  enum Enum
1645  {
1646  NoValue = 0xFFFF,
1647 
1648  BlockTrade = 1,
1649  ExchangeForPhysical = 2,
1650  EFS = 12,
1651  PortfolioCompressionTrade = 50,
1652  OTC = 54,
1653  ExchangeBasisFacility = 55,
1654  VolaTrade = 1000,
1655  EFPFinTrade = 1001,
1656  EFPIndexFuturesTrade = 1002,
1657  BlockTradeAtMarket = 1004,
1658  XetraEurexEnlightTriggeredTrade = 1006,
1659  BlockQTPIPTrade = 1007,
1660  TradeAtMarket = 1017
1661  };
1662 
1663  static std::string toString(Enum value);
1664  };
1665 
1666  struct ONIXS_EUREX_EMDI_API MultiLegReportingType // UInt8
1667  {
1668  enum Enum
1669  {
1670  NoValue = 0xFF,
1671 
1672  ///
1673  SingleSecurity = 1,
1674 
1675  ///
1676  IndividualLeg = 2,
1677 
1678  ///
1679  MultiLegSecurity = 3,
1680  };
1681 
1682  static std::string toString(Enum value);
1683  };
1684 
1685  struct ONIXS_EUREX_EMDI_API MultiLegPriceModel // UInt8
1686  {
1687  enum Enum
1688  {
1689  NoValue = 0xFF,
1690 
1691  ///
1692  Standard = 0,
1693 
1694  ///
1695  UserDefined = 1,
1696  };
1697 
1698  static std::string toString(Enum value);
1699  };
1700 
1701  struct ONIXS_EUREX_EMDI_API MDOriginType // UInt8
1702  {
1703  enum Enum
1704  {
1705  NoValue = 0xFF,
1706 
1707  ///
1708  Book = 0,
1709 
1710  ///
1711  OffBook = 1,
1712  };
1713 
1714  static std::string toString(Enum value);
1715  };
1716 
1717  struct ONIXS_EUREX_EMDI_API TESTradSesStatus // UInt8
1718  {
1719  enum Enum
1720  {
1721  NoValue = 0xFF,
1722 
1723  ///
1724  Halted = 1,
1725 
1726  ///
1727  Open = 2,
1728 
1729  ///
1730  Closed = 3,
1731 
1732  ///
1733  PreClose = 4,
1734  };
1735 
1736  static std::string toString(Enum value);
1737  };
1738 
1739 
1740  struct ONIXS_EUREX_EMDI_API TESSecurityStatus // UInt8
1741  {
1742  enum Enum
1743  {
1744  NoValue = 0xFF,
1745 
1746  ///
1747  Active = 1,
1748 
1749  ///
1750  Inactive = 2,
1751 
1752  ///
1753  Expired = 4,
1754 
1755  ///
1756  Suspended = 9,
1757  };
1758 
1759  static std::string toString(Enum value);
1760  };
1761 
1762  struct ONIXS_EUREX_EMDI_API TESSecurityMassStatus // UInt8
1763  {
1764  enum Enum
1765  {
1766  NoValue = 0xFF,
1767 
1768  ///
1769  Active = 1,
1770 
1771  ///
1772  Inactive = 2,
1773 
1774  ///
1775  Expired = 4,
1776 
1777  ///
1778  Suspended = 9,
1779  };
1780 
1781  static std::string toString(Enum value);
1782  };
1783 
1784  }
1785  }
1786  }
1787 }
unsigned int SequenceNumber
Alias for sequence numbers.
Exposes list of available trade session statuses.
Definition: Defines.h:202
UInt32 PartitionId
Alias for Partition ID type.
Definition: Defines.h:48
Exposes list of available sold out indicators.
Definition: Defines.h:878
UInt32 MarketDepth
Alias for Market depth type.
Definition: Defines.h:43
UInt32 senderCompID
Unique id for a sender.
Definition: Defines.h:122
Timestamp packetReceptionTime
Time when the packet was received by Handler from UDP, in system ticks,.
Definition: Defines.h:96
Exposes list of available book types.
Definition: Defines.h:776
Indicator for stressed market conditions.
Definition: Defines.h:811
Exposes list of available security trading statuses.
Definition: Defines.h:436
Exposes list of available origin types.
Definition: Defines.h:648
Exposes list of available update actions.
Definition: Defines.h:664
Exposes list of available market segment statuses.
Definition: Defines.h:708
Exposes list of available trade types.
Definition: Defines.h:298
Exposes list of available security statuses.
Definition: Defines.h:164
Exposes list of available trade conditions.
Definition: Defines.h:528
UInt64 sendingTime
Time when market data feed handler writes packet on the wire.
Definition: Defines.h:112
unsigned int UInt32
Definition: Numeric.h:41
Exposes list of available trading session IDs.
Definition: Defines.h:374
Definition: Defines.h:30
SequenceNumber packetSeqNum
Packet sequence number.
Definition: Defines.h:103
const MarketSegmentId UndefinedMarketSegmentId
Definition: Defines.h:45
Int64 SecurityId
Alias for Security Id type.
Definition: Defines.h:51
std::string MarketSegment
Alias for Market Segment type (Product name).
Definition: Defines.h:37
Exposes list of available instrument types for tick rule.
Definition: Defines.h:727
Feed roles (primary, secondary).
Definition: Defines.h:74
NetFeedRole::Enum Origin
An origin of the packet.
Definition: Defines.h:140
char Base
Integral base type of enumeration.
Definition: Defines.h:77
Represents timestamp without time-zone information.
Definition: Timestamp.h:87
Exposes list of available sub book types.
Definition: Defines.h:795
Exchange for Physical Fin trade.
Definition: Defines.h:331
Feed types based on type of market data service.
Definition: Defines.h:57
bool contain(TradeCondition::Enum value) const
Definition: Defines.h:583
Exchange for Physical.
Definition: Defines.h:316
Exposes list of available trading session sub IDs.
Definition: Defines.h:399
bool isLastInPacket
Indicates whether a message is last in the packet.
Definition: Defines.h:109
char Base
Integral base type of enumeration.
Definition: Defines.h:60
Exposes list of available entry types.
Definition: Defines.h:240
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
Market recovery for MBP (Market By Price) books.
Definition: Defines.h:69
SequenceNumber packetMessageSeqNum
Packet message number.
Definition: Defines.h:106
Exposes list of available aggressor sides.
Definition: Defines.h:692
UInt64 Quantity
Alias for Quantity type.
Definition: Defines.h:54
Indicates whether a synthetic match is occurred.
Definition: Defines.h:1235
Exposes list of leg sides.
Definition: Defines.h:148
Enum
List of known feed roles.
Definition: Defines.h:80
Enum
Feed types based on type of market data service.
Definition: Defines.h:63