OnixS C++ Eurex T7 Market and Reference Data Interface (EMDI, RDI, EOBI) Handlers  11.1.0
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  ///
326 
327  /// Exchange basis facility
329 
330  /// Vola trade
332 
333  /// Exchange for Physical Fin trade
335 
336  /// EFPIndexFutures trade
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  /// Holiday
391  Holiday = 3,
392  };
393  };
394 
395  /// Exposes list of available trading session sub IDs
396  struct ONIXS_EUREX_EMDI_API TradingSessionSubID
397  {
398  enum Enum
399  {
400  /// Used to identify absence of value.
401  Undefined = -1,
402 
403  /// PreTrading
404  PreTrading = 0,
405 
406  /// Continuous
407  Continuous = 1,
408 
409  /// Closing
410  Closing = 2,
411 
412  /// PostTrading
413  PostTrading = 3,
414 
415  /// ScheduledIntradayAuction
416  ScheduledIntradayAuction = 4,
417 
418  /// Quiescent
419  Quiescent = 5,
420 
421  /// AnyAuction
422  AnyAuction = 6,
423 
424  /// ContinuousAuctionIssuer
425  ContinuousAuctionIssuer = 7,
426 
427  /// ContinuousAuctionSpecialist
428  ContinuousAuctionSpecialist
429  };
430  };
431 
432  /// Exposes list of available security trading statuses
433  struct ONIXS_EUREX_EMDI_API SecurityTradingStatus
434  {
435  enum Enum
436  {
437  /// Used to identify absence of value.
438  Undefined = -1,
439 
440  /// Trading Halt
441  TradingHalt = 0,
442 
443  /// Closed
444  Closed = 1,
445 
446  /// Restricted
447  Restricted = 2,
448 
449  /// Book
450  Book = 3,
451 
452  /// Continuous
453  Continuous = 4,
454 
455  /// Opening auction
456  OpeningAuction = 5,
457 
458  /// Opening auction freeze
459  OpeningAuctionFreeze = 6,
460 
461  /// Intraday auction
462  IntradayAuction = 7,
463 
464  /// Intraday auction freeze
465  IntradayAuctionFreeze = 8,
466 
467  /// Circuit breaker auction
468  CircuitBreakerAuction = 9,
469 
470  /// Circuit breaker auction freeze
471  CircuitBreakerAuctionFreeze = 10,
472 
473  /// Closing auction
474  ClosingAuction = 11,
475 
476  /// Closing auction freeze
477  ClosingAuctionFreeze = 12,
478 
479  /// CIPO Auction
480  IPOAuction = 13,
481 
482  /// IPO Auction Freeze
483  IPOAuctionFreeze = 14,
484 
485  ///
487 
488  ///
490 
491  ///
493 
494  ///
495  TradeAtClose
496  };
497  };
498 
499 
500  struct ONIXS_EUREX_EMDI_API SecurityTradingEvent
501  {
502  enum Enum
503  {
504  /// Used to identify absence of value.
505  Undefined = -1,
506 
507  ///
508  None = 0,
509 
510  ///
511  PriceVolatilityAuctionIsExtended = 1,
512 
513  ///
514  PriceVolatilityAuctionIsExtendedAgain = 2,
515  };
516  };
517 
518  /// Exposes list of available trade conditions
519  struct ONIXS_EUREX_EMDI_API TradeCondition
520  {
521  enum Enum
522  {
523  /// Used to identify absence of value.
524  Undefined = 0,
525 
526  /// Exchange last
527  ExchangeLast = 1,
528 
529  /// Opening price
530  OpeningPrice = 2,
531 
532  /// High price
533  HighPrice = 4,
534 
535  /// Low price
536  LowPrice = 8,
537 
538  /// Official closing price
539  OfficialClosingPrice = 16,
540 
541  /// Last auction price
542  LastAuctionPrice = 32,
543 
544  /// Out of sequence ETH
545  OutOfSequenceETH = 64,
546 
547  /// Previous Closing Price
548  PreviousClosingPrice = 128,
549 
550  /// Volume Only
551  VolumeOnly = 256,
552 
553  /// Midpoint Price
554  MidpointPrice = 512,
555 
556  ///
557  TradingOnTermsOfIssue = 1024,
558 
559  ///
560  SpecialAuction = 2048,
561 
562  ///
563  TradeAtClose = 4096
564  };
565  };
566 
567  struct ONIXS_EUREX_EMDI_API TradeConditionSet
568  {
569  explicit
570  TradeConditionSet (UInt64 value)
571  : value_ (value)
572  {}
573 
574  bool contain (TradeCondition::Enum value) const
575  {
576  return (value_ & value) != 0;
577  }
578 
579  bool containExchangeLast() const
580  {
581  return contain (TradeCondition::ExchangeLast);
582  }
583  bool containOpeningPrice() const
584  {
585  return contain (TradeCondition::OpeningPrice);
586  }
587  bool containHighPrice() const
588  {
589  return contain (TradeCondition::HighPrice);
590  }
591  bool containLowPrice() const
592  {
593  return contain (TradeCondition::LowPrice);
594  }
596  {
597  return contain (TradeCondition::OfficialClosingPrice);
598  }
600  {
601  return contain (TradeCondition::LastAuctionPrice);
602  }
604  {
605  return contain (TradeCondition::OutOfSequenceETH);
606  }
608  {
609  return contain (TradeCondition::PreviousClosingPrice);
610  }
611  bool containVolumeOnly() const
612  {
613  return contain (TradeCondition::VolumeOnly);
614  }
615  bool containMidpointPrice() const
616  {
617  return contain (TradeCondition::MidpointPrice);
618  }
620  {
622  }
624  {
625  return contain (TradeCondition::SpecialAuction);
626  }
627  bool containTradeAtClose() const
628  {
629  return contain(TradeCondition::TradeAtClose);
630  }
631 
632  std::string toString() const;
633 
634  private:
635  UInt64 value_;
636  };
637 
638  /// Exposes list of available origin types
639  struct ONIXS_EUREX_EMDI_API MDOriginType
640  {
641  enum Enum
642  {
643  /// Used to identify absence of value.
644  Undefined = -1,
645 
646  ///
647  Book = 0,
648 
649  ///
650  OffBook = 1,
651  };
652  };
653 
654  /// Exposes list of available update actions
655  struct ONIXS_EUREX_EMDI_API MDUpdateAction
656  {
657  enum Enum
658  {
659  /// Used to identify absence of value.
660  Undefined = -1,
661 
662  /// New
663  New = 0,
664 
665  /// Change
666  Change = 1,
667 
668  /// Delete
669  Delete = 2,
670 
671  /// DeleteThru
672  DeleteThru = 3,
673 
674  /// DeleteFrom
675  DeleteFrom = 4,
676 
677  /// Overlay
678  Overlay = 5
679  };
680  };
681 
682  /// Exposes list of available aggressor sides
683  struct ONIXS_EUREX_EMDI_API Side
684  {
685  enum Enum
686  {
687  /// Used to identify absence of value.
688  Undefined = -1,
689 
690  /// Buy
691  Buy = 1,
692 
693  /// Sell
694  Sell = 2,
695  };
696  };
697 
698  /// Exposes list of available market segment statuses.
699  struct ONIXS_EUREX_EMDI_API MarketSegmentStatus
700  {
701  enum Enum
702  {
703  /// Used to identify absence of value.
704  Undefined = -1,
705 
706  /// Defines if product is traded on on NTA.
707  Active = 0,
708 
709  /// Inactive
710  Inactive = 1,
711 
712  /// Defines if product is still traded on "Eurex classic"
713  Published = 2,
714  };
715  };
716 
717  /// Exposes list of available instrument types for tick rule.
718  struct ONIXS_EUREX_EMDI_API InstrumentType
719  {
720  enum Enum
721  {
722  /// Used to identify absence of value.
723  Undefined = -1,
724 
725  /// Simple instrument
726  SimpleInstrument = 1,
727 
728  /// Standard option strategy
729  StandardOptionStrategy = 2,
730 
731  /// Non standard option strategy
732  NonStandardOptionStrategy = 3,
733 
734  /// Volatility strategy
735  VolatilityStrategy = 4,
736 
737  /// Futures spread
738  FuturesSpread = 5,
739 
740  /// Inter Product Spread
741  InterProductSpread = 6,
742 
743  /// Standard Futures Strategy
744  StandardFuturesStrategy = 7,
745 
746  /// Pack And Bundle
747  PackAndBundle = 8,
748 
749  /// Strip
750  Strip = 9,
751 
752  /// Flexible
753  Flexible = 10,
754  };
755  };
756 
757  /// Exposes list of available book types.
758  struct ONIXS_EUREX_EMDI_API BookType
759  {
760  enum Enum
761  {
762  /// Used to identify absence of value.
763  Undefined = -1,
764 
765  /// Top Of Book
766  TopOfBook = 0,
767 
768  /// Price Depth
769  PriceDepth = 1,
770 
771  /// Order Depth
772  OrderDepth = 2,
773  };
774  };
775 
776  /// Exposes list of available sub book types.
777  struct ONIXS_EUREX_EMDI_API SubBookType
778  {
779  enum Enum
780  {
781  /// Used to identify absence of value.
782  Undefined = -1,
783 
784  /// Price Depth
785  IPSImpliedVolumeWithoutQuantityRestriction = 0,
786 
787  /// Order Depth
788  IPSImpliedVolumeWithQuantityRestriction = 1,
789  };
790  };
791 
792  /// Indicator for stressed market conditions.
793  struct ONIXS_EUREX_EMDI_API MarketCondition
794  {
795  enum Enum
796  {
797  /// Used to identify absence of value.
798  Undefined = -1,
799 
800  /// Normal
801  Normal = 0,
802 
803  /// Stressed
804  Stressed = 1
805  };
806  };
807 
808  /// A trade has to be flagged as "algorithmic", if at least one of the
809  /// matched orders was submitted by a trading algorithm.Applicable
810  /// for cash market products only.
811  struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator
812  {
813  enum Enum
814  {
815  /// Used to identify absence of value.
816  Undefined = -1,
817 
818  /// Algorithmic Trade
819  AlgorithmicTrade = 1
820  };
821  };
822 
823  /// MultiLegReportingType
824  struct ONIXS_EUREX_EMDI_API MultiLegReportingType
825  {
826  enum Enum
827  {
828  /// Used to identify absence of value.
829  Undefined = -1,
830 
831  /// Single Security
832  SingleSecurity = 1,
833 
834  /// Individual Leg Of A MultiLeg Security
835  IndividualLegOfMultiLegSecurity = 2,
836 
837  /// Multi Leg Security
838  MultiLegSecurity = 3
839  };
840  };
841 
842  /// MultiLegPriceModel
843  struct ONIXS_EUREX_EMDI_API MultiLegPriceModel
844  {
845  enum Enum
846  {
847  /// Used to identify absence of value.
848  Undefined = -1,
849 
850  /// Standard
851  Standard = 0,
852 
853  /// User Defined
854  UserDefined = 2
855  };
856  };
857 
858 
859  /// Exposes list of available sold out indicators.
860  struct ONIXS_EUREX_EMDI_API SoldOutIndicator
861  {
862  enum Enum
863  {
864  /// Used to identify absence of value.
865  Undefined = -1,
866 
867  ///
868  SoldOut = 1,
869  };
870  };
871 
872  namespace EOBI
873  {
874  /// Alias for Quantity Type
875  /// Quantity in integer format including 4 decimals.
876  typedef Int64 QuantityType;
877 
878  struct ONIXS_EUREX_EMDI_API AggressorSide // UInt8
879  {
880  enum Enum
881  {
882  /// Used to identify absence of value
883  NoValue = 0xFF,
884 
885  /// Triggered by the buy side
886  Buy = 1,
887 
888  /// Triggered by the sell side
889  Sell = 2,
890  };
891 
892  static std::string toString (Enum value);
893  };
894 
895  struct ONIXS_EUREX_EMDI_API ApplSeqResetIndicator // UInt8
896  {
897  enum Enum
898  {
899  NoValue = 0xFF,
900  NoReset = 0,
901  Reset = 1,
902  };
903 
904  static std::string toString (Enum value);
905  };
906 
907  struct ONIXS_EUREX_EMDI_API CompletionIndicator // UInt8
908  {
909  enum Enum
910  {
911  NoValue = 0xFF,
912  Incomplete = 0,
913  Complete = 1,
914  };
915 
916  static std::string toString (Enum value);
917  };
918 
919  struct ONIXS_EUREX_EMDI_API FastMarketIndicator // UInt8
920  {
921  enum Enum
922  {
923  NoValue = 0xFF,
924  No = 0,
925  Yes = 1,
926  };
927 
928  static std::string toString (Enum value);
929  };
930 
931  struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator // UInt8
932  {
933  enum Enum
934  {
935  NoValue = 0xFF,
936  NotImplied = 0,
937  ImpliedInOut = 3,
938  };
939 
940  static std::string toString (Enum value);
941  };
942 
943  struct ONIXS_EUREX_EMDI_API LegSecurityIDSource // String(1)
944  {
945  enum Enum
946  {
947  NoValue = 0,
948  Marketplace = 'M',
949  };
950 
951  static std::string toString (Enum value);
952  };
953 
954  struct ONIXS_EUREX_EMDI_API LegSide // UInt8
955  {
956  enum Enum
957  {
958  NoValue = 0xFF,
959  Buy = 1,
960  Sell = 2,
961  };
962 
963  static std::string toString (Enum value);
964  };
965 
966  struct ONIXS_EUREX_EMDI_API MDEntryType // UInt8
967  {
968  enum Enum
969  {
970  NoValue = 0xFF,
971  Trade = 2,
972  OpeningPrice = 4,
973  ClosingPrice = 5,
974  HighPrice = 7,
975  LowPrice = 8,
976  TradeVolume = 66,
977  PreviousClosingPrice = 101,
978  OpeningAuction = 200,
979  IntradayAuction = 201,
980  CircuitBreakerAuction = 202,
981  ClosingAuction = 203,
982  IPOAuction = 204,
983  };
984 
985  static std::string toString (Enum value);
986  };
987 
988  struct ONIXS_EUREX_EMDI_API MDReportEvent // UInt8
989  {
990  enum Enum
991  {
992  NoValue = 0xFF,
993  ScopeDefinition = 0,
994  };
995  };
996 
997  struct ONIXS_EUREX_EMDI_API MDUpdateAction // UInt8
998  {
999  enum Enum
1000  {
1001  NoValue = 0xFF,
1002  New = 0,
1003  Change = 1,
1004  Delete = 2,
1005  Overlay = 5,
1006  };
1007  };
1008 
1009  struct ONIXS_EUREX_EMDI_API MarketDataType // UInt8
1010  {
1011  enum Enum
1012  {
1013  NoValue = 0xFF,
1014  OrderBookMaintenance = 1,
1015  OrderBookExecution = 2,
1018  AuctionBBO = 5,
1020  CrossTradeAnnouncement = 7,
1022  MarketSegmentSnapshot = 9,
1023  SingleInstrumentSnapshot = 10,
1024  OrderBookSnapshot = 11,
1025  MatchEvent = 12,
1027  };
1028  };
1029 
1030  struct ONIXS_EUREX_EMDI_API MatchSubType // UInt8
1031  {
1032  enum Enum
1033  {
1034  NoValue = 0xFF,
1035  OpeningAuction = 1,
1036  ClosingAuction = 2,
1037  IntradayAuction = 3,
1038  CircuitBreakerAuction = 4,
1039  IPOAuction = 5,
1040  };
1041 
1042  static std::string toString (Enum value);
1043  };
1044 
1045  struct ONIXS_EUREX_EMDI_API MatchType // UInt8
1046  {
1047  enum Enum
1048  {
1049  NoValue = 0xFF,
1050  ConfirmedTradeReport = 3,
1051  CrossAuction = 5,
1052  CallAuction = 7,
1053  };
1054 
1055  static std::string toString (Enum value);
1056  };
1057 
1058  struct ONIXS_EUREX_EMDI_API NoMarketSegments // UInt8
1059  {
1060  enum Enum
1061  {
1062  NoValue = 0xFF,
1063  One = 1,
1064  };
1065 
1066  static std::string toString (Enum value);
1067  };
1068 
1069  struct ONIXS_EUREX_EMDI_API ProductComplex // UInt8
1070  {
1071  enum Enum
1072  {
1073  NoValue = 0xFF,
1074 
1075  SimpleInstrument = 1,
1076  StandardOptionStrategy = 2,
1077  NonStandardOptionStrategy = 3,
1078  VolatilityStrategy = 4,
1079  FuturesSpread = 5,
1080  InterProductSpread = 6,
1081  StandardFuturesStrategy = 7,
1082  PackAndBundle = 8,
1083  Strip = 9,
1084  };
1085 
1086  static std::string toString (Enum value);
1087  };
1088 
1089  struct ONIXS_EUREX_EMDI_API SecurityIDSource // String(1)
1090  {
1091  enum Enum
1092  {
1093  NoValue = 0,
1094  Marketplace = 'M',
1095  };
1096 
1097  static std::string toString (Enum value);
1098  };
1099 
1100  struct ONIXS_EUREX_EMDI_API SecurityStatus // UInt8
1101  {
1102  enum Enum
1103  {
1104  NoValue = 0xFF,
1105  Active = 1,
1106  Inactive = 2,
1107  Expired = 4,
1108  Suspended = 9,
1109  PendingDeletion = 11,
1110  };
1111 
1112  static std::string toString (Enum value);
1113  };
1114 
1115  struct ONIXS_EUREX_EMDI_API SecurityTradingStatus // UInt8
1116  {
1117  enum Enum
1118  {
1119  NoValue = 0xFF,
1120 
1121  TradingHalt = 2,
1122  MarketImbalanceBuy = 7,
1123  MarketImbalanceSell = 8,
1124  Closed = 200,
1125  Restricted = 201,
1126  Book = 202,
1127  Continuous = 203,
1128  OpeningAuction = 204,
1129  OpeningAuctionFreeze = 205,
1130  IntradayAuction = 206,
1131  IntradayAuctionFreeze = 207,
1132  CircuitBreakerAuction = 208,
1133  CircuitBreakerAuctionFreeze = 209,
1134  ClosingAuction = 210,
1135  ClosingAuctionFreeze = 211,
1136  IPOAuction = 212,
1137  IPOAuctionFreeze = 213,
1138  PreCall = 214,
1139  Call = 215,
1140  Freeze = 216,
1141  TradeAtClose = 217
1142  };
1143 
1144  static std::string toString (Enum value);
1145  };
1146 
1147  struct ONIXS_EUREX_EMDI_API SecurityType // String(4)
1148  {
1149  enum Enum
1150  {
1151  NoValue = 0,
1152  Option = 'O', // OPT,
1153  Future = 'F', // FUT,
1154  MultiLeg = 'M' // MLEG,
1155  };
1156 
1157  static std::string toString (Enum value);
1158  };
1159 
1160  struct ONIXS_EUREX_EMDI_API SecurityUpdateAction // String(1)
1161  {
1162  enum Enum
1163  {
1164  NoValue = 0,
1165  Add = 'A',
1166  Delete = 'D',
1167  };
1168 
1169  static std::string toString (Enum value);
1170  };
1171 
1172  struct ONIXS_EUREX_EMDI_API Side // UInt8
1173  {
1174  enum Enum
1175  {
1176  NoValue = 0xFF,
1177  Buy = 1,
1178  Sell = 2,
1179  };
1180 
1181  static std::string toString (Enum value);
1182  };
1183 
1184  /// Indicates whether a synthetic match is occurred.
1185  struct ONIXS_EUREX_EMDI_API TradeCondition // UInt16
1186  {
1187  enum Enum
1188  {
1189  NoValue = 0xFF,
1190  ImpliedTrade = 1,
1191  OutOfSequence = 107,
1192  MidpointPrice = 155,
1193  TradingOnTermsOfIssue = 156,
1194  SpetialAuction = 596,
1195  TradeAtClose = 624
1196  };
1197 
1198  static std::string toString (Enum value);
1199  };
1200 
1201  struct ONIXS_EUREX_EMDI_API TradSesEvent // UInt8
1202  {
1203  enum Enum
1204  {
1205  NoValue = 0xFF,
1206  TBD = 0,
1207  StatusChange = 3,
1208  };
1209 
1210  static std::string toString (Enum value);
1211  };
1212 
1213  struct ONIXS_EUREX_EMDI_API TradSesStatus // UInt8
1214  {
1215  enum Enum
1216  {
1217  NoValue = 0xFF,
1218  Halted = 1,
1219  Open = 2,
1220  Closed = 3,
1221  };
1222 
1223  static std::string toString (Enum value);
1224  };
1225 
1226  struct ONIXS_EUREX_EMDI_API TradingSessionID // UInt8
1227  {
1228  enum Enum
1229  {
1230  NoValue = 0xFF,
1231  Day = 1,
1232  Morning = 3,
1233  Evening = 5,
1234  AfterHours = 6,
1235  Holiday = 7,
1236  };
1237 
1238  static std::string toString (Enum value);
1239  };
1240 
1241  struct ONIXS_EUREX_EMDI_API TradingSessionSubID // UInt8
1242  {
1243  enum Enum
1244  {
1245  NoValue = 0xFF,
1246  PreTrading = 1,
1247  Continuous = 3,
1248  Closing = 4,
1249  PostTrading = 5,
1250  Quiescent = 7,
1251  };
1252 
1253  static std::string toString (Enum value);
1254  };
1255 
1256 
1257  struct ONIXS_EUREX_EMDI_API PotentialSecurityTradingEvent // UInt8
1258  {
1259  enum Enum
1260  {
1261  NoValue = 0xFF,
1262 
1263  /// None
1264  None = 0,
1265 
1266  /// Price volatility, auction is extended
1267  PriceVolatilityAuctionIsExtended = 10,
1268  };
1269 
1270  static std::string toString (Enum value);
1271  };
1272 
1273  struct ONIXS_EUREX_EMDI_API OrdType // UInt8
1274  {
1275  enum Enum
1276  {
1277  NoValue = 0xFF,
1278 
1279  /// Market Order
1280  MarketOrder = 1,
1281  };
1282 
1283  static std::string toString(Enum value);
1284  };
1285 
1286  struct ONIXS_EUREX_EMDI_API SecurityTradingEvent // UInt8
1287  {
1288  enum Enum
1289  {
1290  NoValue = 0xFF,
1291 
1292  /// Price volatility, auction is extended
1293  PriceVolatilityAuctionIsExtended = 10,
1294 
1295  /// Price volatility, auction is extended again
1296  PriceVolatilityAuctionIsExtendedAgain = 11,
1297  };
1298 
1299  static std::string toString (Enum value);
1300  };
1301 
1302  struct ONIXS_EUREX_EMDI_API OrderType // UInt8
1303  {
1304  enum Enum
1305  {
1306  NoValue = 0xFF,
1307 
1308  ///
1309  MarketOrder = 1,
1310  };
1311 
1312  static std::string toString (Enum value);
1313  };
1314 
1315  struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator // UInt8
1316  {
1317  enum Enum
1318  {
1319  NoValue = 0xFF,
1320 
1321  ///
1322  AlgorithmicTrade = 1,
1323  };
1324 
1325  static std::string toString(Enum value);
1326  };
1327 
1328  struct ONIXS_EUREX_EMDI_API MarketCondition // UInt8
1329  {
1330  enum Enum
1331  {
1332  NoValue = 0xFF,
1333 
1334  ///
1335  Normal = 0,
1336 
1337  ///
1338  Stressed = 1
1339  };
1340 
1341  static std::string toString(Enum value);
1342  };
1343 
1344  struct ONIXS_EUREX_EMDI_API LegSecurityType // UInt8
1345  {
1346  enum Enum
1347  {
1348  NoValue = 0xFF,
1349 
1350  ///
1351  LegSecurityMultiLeg = 0,
1352 
1353  ///
1354  LegSecurityUnderlyingLeg = 1
1355  };
1356 
1357  static std::string toString(Enum value);
1358  };
1359 
1360  struct ONIXS_EUREX_EMDI_API SoldOutIndicator // UInt8
1361  {
1362  enum Enum
1363  {
1364  NoValue = 0xFF,
1365 
1366  ///
1367  SoldOut = 1,
1368  };
1369 
1370  static std::string toString(Enum value);
1371  };
1372 
1373  struct ONIXS_EUREX_EMDI_API InstrumentScopeProductComplex // UInt8
1374  {
1375  enum Enum
1376  {
1377  NoValue = 0xFF,
1378 
1379  ///
1380  SimpleInstrument = 1,
1381 
1382  ///
1383  StandardOptionStrategy = 2,
1384 
1385  ///
1386  NonStandardOptionStrategy = 3,
1387 
1388  ///
1389  VolatilityStrategy = 4,
1390 
1391  ///
1392  FuturesSpread = 5,
1393 
1394  ///
1395  InterProductSpread = 6,
1396 
1397  ///
1398  StandardFuturesStrategy = 7,
1399 
1400  ///
1401  PackAndBundle = 8,
1402 
1403  ///
1404  Strip = 9
1405  };
1406 
1407  static std::string toString(Enum value);
1408  };
1409 
1410  struct ONIXS_EUREX_EMDI_API SecurityMassStatus // UInt8
1411  {
1412  enum Enum
1413  {
1414  NoValue = 0xFF,
1415 
1416  ///
1417  Active = 1,
1418 
1419  ///
1420  Inactive = 2,
1421 
1422  ///
1423  Expired = 4,
1424 
1425  ///
1426  KnockedOut = 6,
1427 
1428  ///
1429  KnockOutRevoked = 7,
1430 
1431  ///
1432  Suspended = 9,
1433 
1434  ///
1435  PendingDeletion = 11,
1436 
1437  ///
1438  KnockedOutAndSuspended = 12
1439  };
1440 
1441  static std::string toString(Enum value);
1442  };
1443 
1444  struct ONIXS_EUREX_EMDI_API SecurityMassTradingStatus // UInt8
1445  {
1446  enum Enum
1447  {
1448  NoValue = 0xFF,
1449 
1450  ///
1451  TradingHalt = 2,
1452 
1453  ///
1454  MarketImbalanceBuy = 7,
1455 
1456  ///
1457  MarketImbalanceSell = 8,
1458 
1459  ///
1460  Closed = 200,
1461 
1462  ///
1463  Restricted = 201,
1464 
1465  ///
1466  Book = 202,
1467 
1468  ///
1469  Continuous = 203,
1470 
1471  ///
1472  OpeningAuction = 204,
1473 
1474  ///
1475  OpeningAuctionFreeze = 205,
1476 
1477  ///
1478  IntradayAuction = 206,
1479 
1480  ///
1481  IntradayAuctionFreeze = 207,
1482 
1483  ///
1484  CircuitBreakerAuction = 208,
1485 
1486  ///
1487  CircuitBreakerAuctionFreeze = 209,
1488 
1489  ///
1490  ClosingAuction = 210,
1491 
1492  ///
1493  ClosingAuctionFreeze = 211,
1494 
1495  ///
1496  IPOAuction = 212,
1497 
1498  ///
1499  IPOAuctionFreeze = 213,
1500 
1501  ///
1502  PreCall = 214,
1503 
1504  ///
1505  Call = 215,
1506 
1507  ///
1508  Freeze = 216,
1509 
1510  ///
1511  TradeAtClose = 217
1512  };
1513 
1514  static std::string toString(Enum value);
1515  };
1516 
1517  struct ONIXS_EUREX_EMDI_API MassMarketCondition // UInt8
1518  {
1519  enum Enum
1520  {
1521  NoValue = 0xFF,
1522 
1523  ///
1524  Normal = 0,
1525 
1526  ///
1527  Stressed = 1
1528  };
1529 
1530  static std::string toString(Enum value);
1531  };
1532 
1533  struct ONIXS_EUREX_EMDI_API SecurityMassTradingEvent // UInt8
1534  {
1535  enum Enum
1536  {
1537  NoValue = 0xFF,
1538 
1539  /// Price volatility, auction is extended
1540  PriceVolatilityAuctionIsExtended = 10,
1541 
1542  /// Price volatility, auction is extended again
1543  PriceVolatilityAuctionIsExtendedAgain = 11
1544  };
1545 
1546  static std::string toString(Enum value);
1547  };
1548 
1549  struct ONIXS_EUREX_EMDI_API MassSoldOutIndicator // UInt8
1550  {
1551  enum Enum
1552  {
1553  NoValue = 0xFF,
1554 
1555  ///
1556  SoldOut = 1,
1557  };
1558 
1559  static std::string toString(Enum value);
1560  };
1561 
1562 
1563  struct ONIXS_EUREX_EMDI_API LastFragment // UInt8
1564  {
1565  enum Enum
1566  {
1567  NoValue = 0xFF,
1568 
1569  ///
1570  N = 0,
1571 
1572  ///
1573  Y = 1,
1574  };
1575 
1576  static std::string toString(Enum value);
1577  };
1578 
1579 
1580  }
1581  }
1582  }
1583 }
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:860
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:758
Indicator for stressed market conditions.
Definition: Defines.h:793
Exposes list of available security trading statuses.
Definition: Defines.h:433
Exposes list of available origin types.
Definition: Defines.h:639
Exposes list of available update actions.
Definition: Defines.h:655
Exposes list of available market segment statuses.
Definition: Defines.h:699
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:519
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:718
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:777
Exchange for Physical Fin trade.
Definition: Defines.h:334
Feed types based on type of market data service.
Definition: Defines.h:57
bool contain(TradeCondition::Enum value) const
Definition: Defines.h:574
Exchange for Physical.
Definition: Defines.h:316
Exposes list of available trading session sub IDs.
Definition: Defines.h:396
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:683
UInt64 Quantity
Alias for Quantity type.
Definition: Defines.h:54
Indicates whether a synthetic match is occurred.
Definition: Defines.h:1185
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