Defines.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/

#pragma once

#include <string>

#include <OnixS/Eurex/MarketData/ABI.h>
#include <OnixS/Eurex/MarketData/Numeric.h>
#include <OnixS/Eurex/MarketData/SequenceNumber.h>
#include <OnixS/Eurex/MarketData/TimeSpan.h>
#include <OnixS/Eurex/MarketData/Timestamp.h>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Alias for Market Segment type (Product name).
            typedef std::string MarketSegment;

            /// Alias for Market Segment ID type.
            typedef UInt32 MarketSegmentId;

            /// Alias for Market depth type.
            typedef UInt32 MarketDepth;

            const MarketSegmentId UndefinedMarketSegmentId = 0;

            /// Alias for Partition ID type.
            typedef UInt32 PartitionId;

            /// Alias for Security Id type.
            typedef Int64 SecurityId;

            /// Alias for Quantity type.
            typedef UInt64 Quantity;

            struct DataSource
            {
                /// Time when the packet was received by Handler from UDP, in system ticks, @see Time.h
                Timestamp packetReceptionTime;

                /// Time when the packet was originally received by Handler from UDP
                /// Valid only for backtesting
                Timestamp originalPacketReceptionTime;

                /// Packet sequence number
                SequenceNumber packetSeqNum;

                /// Packet message number
                SequenceNumber packetMessageSeqNum;

                /// Indicates whether a message is last in the packet
                bool isLastInPacket;

                /// Time when market data feed handler writes packet on the wire.
                UInt64 sendingTime;

                /// Current load of system.
                ///
                /// @note Time difference between the incoming ETS-order/quote
                /// and the time the market data is written to the socket. This
                /// information is provided for the incremental feed of Eurex EMDI only.
                UInt32 performanceIndicator;

                /// Unique id for a sender.
                UInt32 senderCompID;

                /// Sending partition.
                ///
                /// @note For EMDI feed messages only.
                PartitionId partitionId;

                /// Product identifier
                ///
                /// @note For EOBI feed messages only.
                MarketSegmentId marketSegmentId;

                /// An indicator whether the atomic unit of work fits into one datagram
                ///
                /// @note For EOBI feed messages only.
                bool completionIndicator;

                enum Origin
                {
                    /// Origin is unknown or lost
                    Undefined,

                    /// FeedA
                    FeedA,

                    /// FeedB
                    FeedB
                };

                Origin origin;

                bool cached;
            };

            /// Exposes list of available security update actions
            namespace SecurityUpdateAction
            {
                /// Add
                const std::string Add = "A";
            };

            /// Exposes list of leg sides
            struct ONIXS_EUREX_EMDI_API LegSide
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Buy
                    Buy = 1,

                    /// Sell
                    Sell = 2,
                };
            };

            /// Exposes list of available security statuses
            struct ONIXS_EUREX_EMDI_API SecurityStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Defines if product is traded on on NTA.
                    Active = 0,

                    /// Inactive
                    Inactive = 1,

                    /// Expired
                    Expired = 2,

                    /// 
                    KnockedOut = 3,

                    ///
                    KnockOutRevoked = 4,

                    /// Suspended
                    Suspended = 5,

                    /// Defines if product is still traded on "Eurex classic"
                    Published = 6,

                    /// 
                    PendingDeletion = 7,

                    ///
                    KnockedOutAndSuspended = 8,

                };
            };

            /// Exposes list of available trade session statuses.
            struct ONIXS_EUREX_EMDI_API TradSesStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Halted = 0,

                    ///
                    Open = 1,

                    ///
                    Closed = 2,

                    ///
                    PreClose = 3,
                };
            };


            struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Not implied
                    NotImplied = 0,

                    /// Both implied in and implied out
                    BothImpliedInAndImpliedOut = 1,
                };
            };

            /// Exposes list of available entry types
            struct ONIXS_EUREX_EMDI_API MDEntryType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Bid
                    Bid = 0,

                    /// Offer
                    Offer = 1,

                    /// Trade
                    Trade = 2,

                    /// Empty book
                    EmptyBook = 3,

                    /// Auction clearing price
                    AuctionClearingPrice = 4,

                    /// Settlement Price
                    SettlementPrice = 5,

                    /// Open Interest
                    OpenInterest = 6,

                    ///Trade Volume
                    TradeVolume = 7,

                    ///Market Bid
                    MarketBid = 8,

                    ///Market Offer
                    MarketOffer = 9,

                    ///Imbalance
                    Imbalance = 10,
                };
            };

            struct ONIXS_EUREX_EMDI_API  QuoteCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    // Crossed,
                    Crossed   = 0,

                    // OrderImbalance,
                    OrderImbalance   = 1,
                };
            };

            /// Exposes list of available trade types
            struct ONIXS_EUREX_EMDI_API TrdType
            {
                // The trade type enum entries do not use numeric values
                // mentioned in documentation. Instead they are identified by
                // ordinal (starting from zero) preserving the order in the doc.

                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Regular Trade
                    RegularTrade = 0,

                    /// Block trade
                    BlockTrade,

                    /// Exchange for Physical
                    EFP,

                    /// Exchange for swap
                    ExchangeForSwap,

                    ///
                    OTC,

                    /// Exchange basis facility
                    ExchangeBasisFacility,

                    /// Vola trade
                    VolaTrade,

                    /// Exchange for Physical Fin trade
                    EFPFinTrade,

                    /// EFPIndexFutures trade
                    EFPIndexFuturesTrade,

                    /// 
                    BlockTradeAtMarket,

                    ///
                    XetraEurexEnlightTriggeredTrade,

                    /// Opening auction trade
                    OpeningAuctionTrade,

                    /// Intraday auction trade
                    IntradayAuctionTrade,

                    /// Volatility auction trade
                    VolatilityAuctionTrade,

                    /// Closing auction trade
                    ClosingAuctionTrade,

                    /// Cross auction trade
                    CrossAuctionTrade,

                    /// 
                    IPOAuctionTrade,

                    ///
                    LiquidityImprovementCross
                };

                static std::string toString (Enum value);
            };

            /// Exposes list of available trading session IDs
            struct ONIXS_EUREX_EMDI_API TradingSessionId
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Day
                    Day = 0,

                    /// Morning
                    Morning = 1,

                    /// Evening
                    Evening = 2,

                    /// Holiday
                    Holiday = 3,
                };
            };

            /// Exposes list of available trading session sub IDs
            struct ONIXS_EUREX_EMDI_API TradingSessionSubID
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// PreTrading
                    PreTrading = 0,

                    /// Continuous
                    Continuous = 1,

                    /// Closing
                    Closing = 2,

                    /// PostTrading
                    PostTrading = 3,

                    /// ScheduledIntradayAuction
                    ScheduledIntradayAuction = 4,

                    /// Quiescent
                    Quiescent = 5,

                    /// AnyAuction
                    AnyAuction = 6,

                    /// ContinuousAuctionIssuer
                    ContinuousAuctionIssuer = 7,
                };
            };

            /// Exposes list of available security trading statuses
            struct ONIXS_EUREX_EMDI_API SecurityTradingStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Trading Halt
                    TradingHalt = 0,

                    /// Closed
                    Closed = 1,

                    /// Restricted
                    Restricted = 2,

                    /// Book
                    Book = 3,

                    /// Continuous
                    Continuous = 4,

                    /// Opening auction
                    OpeningAuction = 5,

                    /// Opening auction freeze
                    OpeningAuctionFreeze = 6,

                    /// Intraday auction
                    IntradayAuction = 7,

                    /// Intraday auction freeze
                    IntradayAuctionFreeze = 8,

                    /// Circuit breaker auction
                    CircuitBreakerAuction = 9,

                    /// Circuit breaker auction freeze
                    CircuitBreakerAuctionFreeze = 10,

                    /// Closing auction
                    ClosingAuction = 11,

                    /// Closing auction freeze
                    ClosingAuctionFreeze = 12,

                    /// CIPO Auction
                    IPOAuction = 13,

                    /// IPO Auction Freeze
                    IPOAuctionFreeze = 14,

                    ///
                    PreCall,

                    ///
                    Call,
                };
            };


            struct ONIXS_EUREX_EMDI_API SecurityTradingEvent
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    None = 0,

                    ///
                    PriceVolatilityAuctionIsExtended = 1,

                    ///
                    PriceVolatilityAuctionIsExtendedAgain = 2,
                };
            };

            /// Exposes list of available trade conditions
            struct ONIXS_EUREX_EMDI_API TradeCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = 0,

                    /// Exchange last
                    ExchangeLast = 1,

                    /// Opening price
                    OpeningPrice = 2,

                    /// High price
                    HighPrice = 4,

                    /// Low price
                    LowPrice = 8,

                    /// Official closing price
                    OfficialClosingPrice = 16,

                    /// Last auction price
                    LastAuctionPrice = 32,

                    /// Out of sequence ETH
                    OutOfSequenceETH = 64,

                    /// Previous Closing Price
                    PreviousClosingPrice = 128,

                    /// Volume Only
                    VolumeOnly = 256,

                    /// Systematic Internalizer
                    SystematicInternalizer = 512,

                    /// Midpoint Price
                    MidpointPrice = 1024,
                    
                    ///
                    TradedBeforeIssueDate = 2048,
                };
            };

            struct ONIXS_EUREX_EMDI_API TradeConditionSet
            {
                    TradeConditionSet (UInt64 value)
                        : value_ (value)
                    {}

                    bool contain (TradeCondition::Enum value) const
                    {
                        return (value_ & value) != 0;
                    }

                    bool containExchangeLast() const
                    {
                        return contain (TradeCondition::ExchangeLast);
                    }
                    bool containOpeningPrice() const
                    {
                        return contain (TradeCondition::OpeningPrice);
                    }
                    bool containHighPrice() const
                    {
                        return contain (TradeCondition::HighPrice);
                    }
                    bool containLowPrice() const
                    {
                        return contain (TradeCondition::LowPrice);
                    }
                    bool containOfficialClosingPrice() const
                    {
                        return contain (TradeCondition::OfficialClosingPrice);
                    }
                    bool containLastAuctionPrice() const
                    {
                        return contain (TradeCondition::LastAuctionPrice);
                    }
                    bool containOutOfSequenceETH() const
                    {
                        return contain (TradeCondition::OutOfSequenceETH);
                    }
                    bool containPreviousClosingPrice() const
                    {
                        return contain (TradeCondition::PreviousClosingPrice);
                    }
                    bool containVolumeOnly() const
                    {
                        return contain (TradeCondition::VolumeOnly);
                    }

                    std::string toString() const;

                private:
                    UInt64 value_;
            };

            /// Exposes list of available origin types
            struct ONIXS_EUREX_EMDI_API MDOriginType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Book = 0,

                    ///
                    OffBook = 1,
                };
            };

            /// Exposes list of available update actions
            struct ONIXS_EUREX_EMDI_API MDUpdateAction
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// New
                    New = 0,

                    /// Change
                    Change = 1,

                    /// Delete
                    Delete = 2,

                    /// DeleteThru
                    DeleteThru = 3,

                    /// DeleteFrom
                    DeleteFrom = 4,

                    /// Overlay
                    Overlay = 5
                };
            };

            /// Exposes list of available aggressor sides
            struct ONIXS_EUREX_EMDI_API Side
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Buy
                    Buy = 1,

                    /// Sell
                    Sell = 2,
                };
            };

            /// Exposes list of available trade types
            struct ONIXS_EUREX_EMDI_API OffBookTrdType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Block trade
                    BlockTrade = 0,

                    /// Exchange for Physical
                    EFP,

                    /// Exchange for swap
                    ExchangeForSwap,

                    /// Exchange basis facility
                    ExchangeBasisFacility,

                    /// VolaTrade
                    VolaTrade,

                    /// Exchange for Physical fin trade
                    EFPFinTrade,

                    /// EFPIndexFuturesTrade
                    EFPIndexFuturesTrade,

                    /// Opening auction trade
                    OpeningAuctionTrade,

                    /// Intraday auction trade
                    IntradayAuctionTrade,

                    /// Volatility auction trade
                    VolatilityAuctionTrade,

                    /// Closing auction trade
                    ClosingAuctionTrade,

                    /// Cross auction trade
                    CrossAuctionTrade
                };
            };


            /// Exposes list of available market segment statuses.
            struct ONIXS_EUREX_EMDI_API MarketSegmentStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Defines if product is traded on on NTA.
                    Active = 0,

                    /// Inactive
                    Inactive = 1,

                     /// Defines if product is still traded on "Eurex classic"
                    Published = 2,
                };
            };

            /// Exposes list of available instrument types for tick rule.
            struct ONIXS_EUREX_EMDI_API InstrumentType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Simple instrument
                    SimpleInstrument = 1,

                    /// Standard option strategy
                    StandardOptionStrategy = 2,

                    /// Non standard option strategy
                    NonStandardOptionStrategy = 3,

                    /// Volatility strategy
                    VolatilityStrategy = 4,

                    /// Futures spread
                    FuturesSpread = 5,

                    /// Inter Product Spread
                    InterProductSpread = 6,

                    /// Standard Futures Strategy
                    StandardFuturesStrategy = 7,

                    /// Pack And Bundle
                    PackAndBundle = 8,

                    /// Strip
                    Strip = 9,

                    /// Flexible
                    Flexible = 10,
                };
            };

            /// Exposes list of available book types.
            struct ONIXS_EUREX_EMDI_API BookType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Top Of Book
                    TopOfBook = 0,

                    /// Price Depth
                    PriceDepth = 1,

                    /// Order Depth
                    OrderDepth = 2,
                };
            };

            /// Exposes list of available sub book types.
            struct ONIXS_EUREX_EMDI_API SubBookType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Price Depth
                    IPSImpliedVolumeWithoutQuantityRestriction = 0,

                    /// Order Depth
                    IPSImpliedVolumeWithQuantityRestriction = 1,
                };
            };

            /// Indicator for stressed market conditions.
            struct ONIXS_EUREX_EMDI_API MarketCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Normal
                    Normal = 0, 

                    /// Stressed
                    Stressed = 1
                };
            };

            /// A trade has to be flagged as "algorithmic", if at least one of the
            /// matched orders was submitted by a trading algorithm.Applicable
            /// for cash market products only.
            struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Algorithmic Trade
                    AlgorithmicTrade = 1
                };
            };

            /// MultiLegReportingType
            struct ONIXS_EUREX_EMDI_API MultiLegReportingType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Single Security
                    SingleSecurity = 1, 

                    /// Individual Leg Of A MultiLeg Security
                    IndividualLegOfMultiLegSecurity = 2,

                    /// Multi Leg Security
                    MultiLegSecurity = 3
                };
            };

            /// MultiLegPriceModel
            struct ONIXS_EUREX_EMDI_API MultiLegPriceModel
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Standard
                    Standard = 0,

                    /// User Defined
                    UserDefined = 2
                };
            };


            /// Exposes list of available sold out indicators.
            struct ONIXS_EUREX_EMDI_API SoldOutIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    NotSoldOut = 0,

                    ///
                    SoldOut = 1,
                };
            };

            namespace EOBI
            {
                /// Alias for Quantity Type
                /// Quantity in integer format including 4 decimals.
                typedef Int64 QuantityType;

                struct ONIXS_EUREX_EMDI_API AggressorSide // UInt8
                {
                    enum Enum
                    {
                        /// Used to identify absence of value
                        NoValue = 0xFF,

                        /// Triggered by the buy side
                        Buy = 1,

                        /// Triggered by the sell side
                        Sell = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ApplSeqResetIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        NoReset = 0,
                        Reset   = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API CompletionIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        Incomplete  = 0,
                        Complete    = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API FastMarketIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        No      = 0,
                        Yes     = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue      = 0xFF,
                        NotImplied   = 0,
                        ImpliedInOut = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API LegSecurityIDSource // String(1)
                {
                    enum Enum
                    {
                        NoValue     = 0,
                        Marketplace = 'M',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API LegSide // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Buy     = 1,
                        Sell    = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MDEntryType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        Trade                   = 2,
                        OpeningPrice            = 4,
                        ClosingPrice            = 5,
                        HighPrice               = 7,
                        LowPrice                = 8,
                        TradeVolume             = 66,
                        PreviousClosingPrice    = 101,
                        OpeningAuction          = 200,
                        IntradayAuction         = 201,
                        CircuitBreakerAuction   = 202,
                        ClosingAuction          = 203,
                        IPOAuction              = 204,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MDReportEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,
                        ScopeDefinition = 0,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MDUpdateAction // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        New     = 0,
                        Change  = 1,
                        Delete  = 2,
                        Overlay = 5,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MarketDataType // UInt8
                {
                    enum Enum
                    {
                        NoValue                     = 0xFF,
                        OrderBookMaintenance        = 1,
                        OrderBookExecution          = 2,
                        TradeReversal               = 3,
                        TradeReport                 = 4,
                        AuctionBBO                  = 5,
                        AuctionClearingPrice        = 6,
                        CrossTradeAnnouncement      = 7,
                        QuoteRequest                = 8,
                        MarketSegmentSnapshot       = 9,
                        SingleInstrumentSnapshot    = 10,
                        OrderBookSnapshot           = 11,
                        MatchEvent                  = 12,
                        TopOfBook                   = 13,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MatchSubType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        OpeningAuction          = 1,
                        ClosingAuction          = 2,
                        IntradayAuction         = 3,
                        CircuitBreakerAuction   = 4,
                        IPOAuction              = 5,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MatchType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        ConfirmedTradeReport    = 3,
                        CrossAuction            = 5,
                        CallAuction             = 7,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API NoMarketSegments // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        One     = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ProductComplex // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,

                        StandardOptionStrategy = 2,
                        NonStandardOptionStrategy = 3,
                        VolatilityStrategy = 4,
                        FuturesSpread   = 5,
                        InterProductSpread = 6,
                        StandardFuturesStrategy = 7,
                        PackAndBundle = 8,
                        Strip = 9,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityIDSource // String(1)
                {
                    enum Enum
                    {
                        NoValue     = 0,
                        Marketplace = 'M',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        Active      = 1,
                        Inactive    = 2,
                        Expired     = 4,
                        Suspended   = 9,
                        PendingDeletion = 11,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityTradingStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue                     = 0xFF,

                        TradingHalt                 = 2,
                        MarketImbalanceBuy          = 7,
                        MarketImbalanceSell         = 8,
                        Closed                      = 200,
                        Restricted                  = 201,
                        Book                        = 202,
                        Continuous                  = 203,
                        OpeningAuction              = 204,
                        OpeningAuctionFreeze        = 205,
                        IntradayAuction             = 206,
                        IntradayAuctionFreeze       = 207,
                        CircuitBreakerAuction       = 208,
                        CircuitBreakerAuctionFreeze = 209,
                        ClosingAuction              = 210,
                        ClosingAuctionFreeze        = 211,
                        IPOAuction                  = 212,
                        IPOAuctionFreeze            = 213,
                        PreCall                     = 214,
                        Call                        = 215
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityType // String(4)
                {
                    enum Enum
                    {
                        NoValue  = 0,
                        Option   = 'O', // OPT,
                        Future   = 'F', // FUT,
                        MultiLeg = 'M'  // MLEG,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityUpdateAction // String(1)
                {
                    enum Enum
                    {
                        NoValue = 0,
                        Add     = 'A',
                        Delete  = 'D',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API Side // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Buy     = 1,
                        Sell    = 2,
                    };

                    static std::string toString (Enum value);
                };

                /// Indicates whether a synthetic match is occurred.
                struct ONIXS_EUREX_EMDI_API TradeCondition // UInt8
                {
                    enum Enum
                    {
                        NoValue      = 0xFF,
                        ImpliedTrade = 1,

                        OutOfSequence = 107, 
                        SystematicInternalizer = 153,
                        MidpointPrice = 155,
                        TradedBeforeIssueDate = 156
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradSesEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,
                        TBD             = 0,
                        StatusChange    = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradSesStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Halted  = 1,
                        Open    = 2,
                        Closed  = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradingSessionID // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Day     = 1,
                        Morning = 3,
                        Evening = 5,
                        AfterHours = 6,
                        Holiday = 7,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradingSessionSubID // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        PreTrading  = 1,
                        Continuous = 3,
                        Closing     = 4,
                        PostTrading = 5,
                        Quiescent   = 7,
                    };

                    static std::string toString (Enum value);
                };


                struct ONIXS_EUREX_EMDI_API PotentialSecurityTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        /// None
                        None  = 0,

                        /// Price volatility, auction is extended
                        PriceVolatilityAuctionIsExtended = 10,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API OrdType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        /// Market Order
                        MarketOrder = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        /// Price volatility, auction is extended
                        PriceVolatilityAuctionIsExtended = 10,

                        /// Price volatility, auction is extended again
                        PriceVolatilityAuctionIsExtendedAgain = 11,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API OrderType // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        ///
                        MarketOrder = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        AlgorithmicTrade = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MarketCondition // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Normal = 0,

                        /// 
                        Stressed = 1
                    };

                    static std::string toString(Enum value);
                };
                
                struct ONIXS_EUREX_EMDI_API LegSecurityType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        LegSecurityMultiLeg = 0,

                        ///
                        LegSecurityUnderlyingLeg = 1
                    };

                    static std::string toString(Enum value);
                };

            }
        }
    }
}