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
        {
            typedef std::string MarketSegment;

            typedef UInt32 MarketSegmentId;

            typedef UInt32 MarketDepth;
 
            const MarketSegmentId UndefinedMarketSegmentId = 0;

            typedef UInt32 PartitionId;

            typedef UInt32 SenderCompId;

            typedef Int64 SecurityId;

            typedef UInt64 Quantity;

            struct NetFeedType
            {
                typedef char Base;

                enum Enum
                {
                    Incremental,

                    Snapshot,
                };
            };

            struct NetFeedRole
            {
                typedef char Base;

                enum Enum
                {
                    Undefined,

                    FeedA,

                    FeedB
                };
            };
 
            struct DataSource
            {
                Timestamp packetReceptionTime;

                Timestamp originalPacketReceptionTime;

                SequenceNumber packetSeqNum;

                SequenceNumber packetMessageSeqNum;

                bool isLastInPacket;

                UInt64 sendingTime;

                UInt32 performanceIndicator;

                UInt32 senderCompID;

                PartitionId partitionId;

                MarketSegmentId marketSegmentId;

                bool completionIndicator;

                typedef NetFeedRole::Enum Origin;
                Origin origin;

                bool cached;
            };

            struct ONIXS_EUREX_EMDI_API LegSide
            {
                enum Enum
                {
                    Undefined = -1,

                    Buy = 1,

                    Sell = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API SecurityStatus
            {
                enum Enum
                {
                    Undefined = -1,

                    Active = 0,

                    Inactive = 1,

                    Expired = 2,

                    KnockedOut = 3,

                    KnockOutRevoked = 4,

                    Suspended = 5,

                    Published = 6,

                    PendingDeletion = 7,

                    KnockedOutAndSuspended = 8,
 
                };
            };

            struct ONIXS_EUREX_EMDI_API TradSesStatus
            {
                enum Enum
                {
                    Undefined = -1,

                    Halted = 0,

                    Open = 1,

                    Closed = 2,

                    PreClose = 3,
                };
            };

            struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    NotImplied = 0,

                    BothImpliedInAndImpliedOut = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API MDEntryType
            {
                enum Enum
                {
                    Undefined = -1,

                    Bid = 0,

                    Offer = 1,

                    Trade = 2,

                    EmptyBook = 3,

                    AuctionClearingPrice = 4,

                    SettlementPrice = 5,

                    OpenInterest = 6,

                    TradeVolume = 7,

                    MarketBid = 8,

                    MarketOffer = 9,

                    Imbalance = 10,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API QuoteCondition
            {
                enum Enum
                {
                    Undefined = -1,
 
                    // Crossed,
                    Crossed   = 0,
 
                    // OrderImbalance,
                    OrderImbalance   = 1,
                };
            };

            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
                {
                    Undefined = -1,

                    RegularTrade = 0,

                    BlockTrade,

                    EFP,

                    ExchangeForSwap,

                    OTC,

                    ExchangeBasisFacility,

                    VolaTrade,

                    EFPFinTrade,

                    EFPIndexFuturesTrade,

                    BlockTradeAtMarket,

                    XetraEurexEnlightTriggeredTrade,

                    BlockQTPIPTrade,

                    OpeningAuctionTrade,

                    IntradayAuctionTrade,

                    VolatilityAuctionTrade,

                    ClosingAuctionTrade,

                    CrossAuctionTrade,

                    IPOAuctionTrade,

                    LiquidityImprovementCross,

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

            struct ONIXS_EUREX_EMDI_API TradingSessionId
            {
                enum Enum
                {
                    Undefined = -1,

                    Day = 0,

                    Morning = 1,

                    Evening = 2,

                    AfterHours = 3,

                    Holiday = 4,
                };
            };

            struct ONIXS_EUREX_EMDI_API TradingSessionSubID
            {
                enum Enum
                {
                    Undefined = -1,

                    PreTrading = 0,

                    Continuous = 1,

                    Closing = 2,

                    PostTrading = 3,

                    ScheduledIntradayAuction = 4,

                    Quiescent = 5,

                    AnyAuction = 6,

                    OutOfMainSessionTrading = 7,

                    ContinuousAuctionIssuer = 8,

                    ContinuousAuctionSpecialist
                };
            };

            struct ONIXS_EUREX_EMDI_API TradingStyle
            {
                enum Enum
                {
                    Undefined = -1,

                    Regular = 0,

                    TRF_TAC = 1,
 
                    //
                    TRF_TAM = 2,

                    MOC = 3
                };
            };

            struct ONIXS_EUREX_EMDI_API SecurityTradingStatus
            {
                enum Enum
                {
                    Undefined = -1,

                    TradingHalt = 0,

                    Closed = 1,

                    Restricted = 2,

                    Book = 3,

                    Continuous = 4,

                    OpeningAuction = 5,

                    OpeningAuctionFreeze = 6,

                    IntradayAuction = 7,

                    IntradayAuctionFreeze = 8,

                    CircuitBreakerAuction = 9,

                    CircuitBreakerAuctionFreeze = 10,

                    ClosingAuction = 11,

                    ClosingAuctionFreeze = 12,

                    IPOAuction = 13,

                    IPOAuctionFreeze = 14,

                    PreCall,

                    Call,

                    Freeze,

                    TradeAtClose,

                    RetailPreCall,

                    RetailCall,

                    CircuitBreakerAuctionTriggeredByStaticLimitBreach,

                    CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze
                };
            };

            struct ONIXS_EUREX_EMDI_API SecurityTradingEvent
            {
                enum Enum
                {
                    Undefined = -1,

                    None = 0,

                    PriceVolatilityAuctionIsExtended = 1,

                    PriceVolatilityAuctionIsExtendedAgain = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API TradeCondition
            {
                enum Enum
                {
                    Undefined = 0,

                    ExchangeLast = 1,

                    OpeningPrice = 2,

                    HighPrice = 4,

                    LowPrice = 8,

                    OfficialClosingPrice = 16,

                    LastAuctionPrice = 32,

                    OutOfSequenceETH = 64,

                    PreviousClosingPrice = 128,

                    VolumeOnly = 256,

                    TradingOnTermsOfIssue = 512,

                    SpecialAuction = 1024,

                    TradeAtClose = 2048,

                    Retail = 4096,

                    MidpointPrice = 8192,

                    AuctionVolumeDiscovery = 16384,
                };
            };

            struct ONIXS_EUREX_EMDI_API MidpointTrading
            {
                enum Enum
                {
                    Disabled = 0,

                    Enabled = 1,

                    Undefined = -1,
                };
            };

            struct ONIXS_EUREX_EMDI_API SecurityClassificationReasonType
            {
                enum Enum
                {
                    Fee = 0,

                    CreditControls = 1,

                    Margin = 2,

                    EntitlementOrEligibility = 3,

                    MarketData = 4,

                    AccountSelection = 5,

                    DeliveryProcess = 6,

                    Sector = 7,

                    Undefined = -1,
                };
            };
 

            struct ONIXS_EUREX_EMDI_API SecurityClassificationValueType
            {
                enum Enum
                {
                    EligibleForAllTradingActivities = 1,

                    NotEligibleForOTCTradeUpload = 2,

                    EligibleOnlyForOTCTradeUpload = 3,

                    Undefined = -1,
                };
            };
 
 
            struct ONIXS_EUREX_EMDI_API TradeConditionSet
            {
                explicit
                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);
                }
                bool containRetail() const
                {
                    return contain (TradeCondition::Retail);
                }
                bool containTradingOnTermsOfIssue() const
                {
                    return contain(TradeCondition::TradingOnTermsOfIssue);
                }
                bool containSpecialAuction() const
                {
                    return contain (TradeCondition::SpecialAuction);
                }
                bool containTradeAtClose() const
                {
                    return contain(TradeCondition::TradeAtClose);
                }
                bool containMidpointPrice() const
                {
                    return contain(TradeCondition::MidpointPrice);
                }
                bool containAuctionVolumeDiscovery() const
                {
                    return contain(TradeCondition::AuctionVolumeDiscovery);
                }
 
                std::string toString() const;
 
            private:
                UInt64 value_;
            };

            struct ONIXS_EUREX_EMDI_API MDOriginType
            {
                enum Enum
                {
                    Undefined = -1,

                    Book = 0,

                    OffBook = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API MDUpdateAction
            {
                enum Enum
                {
                    Undefined = -1,

                    New = 0,

                    Change = 1,

                    Delete = 2,

                    DeleteThru = 3,

                    DeleteFrom = 4,

                    Overlay = 5
                };
            };

            struct ONIXS_EUREX_EMDI_API Side
            {
                enum Enum
                {
                    Undefined = -1,

                    Buy = 1,

                    Sell = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API MarketSegmentStatus
            {
                enum Enum
                {
                    Undefined = -1,

                    Active = 0,

                    Inactive = 1,

                    Published = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API InstrumentType
            {
                enum Enum
                {
                    Undefined = -1,

                    SimpleInstrument = 1,

                    StandardOptionStrategy = 2,

                    NonStandardOptionStrategy = 3,

                    VolatilityStrategy = 4,

                    FuturesSpread = 5,

                    InterProductSpread = 6,

                    StandardFuturesStrategy = 7,

                    PackAndBundle = 8,

                    Strip = 9,

                    Flexible = 10,

                    CommodityStrips = 11,

                    ScaledSimpleInstrument = 12,

                    NonStandardVolatilityStrategy = 13,

                    TotalReturnFutureStrategy = 14
                };
            };

            struct ONIXS_EUREX_EMDI_API BookType
            {
                enum Enum
                {
                    Undefined = -1,

                    TopOfBook = 0,

                    PriceDepth = 1,

                    OrderDepth = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API SubBookType
            {
                enum Enum
                {
                    Undefined = -1,

                    IPSImpliedVolumeWithoutQuantityRestriction = 0,

                    IPSImpliedVolumeWithQuantityRestriction = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API MarketCondition
            {
                enum Enum
                {
                    Undefined = -1,

                    Normal = 0,

                    Stressed = 1
                };
            };

            struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    AlgorithmicTrade = 1
                };
            };

            struct ONIXS_EUREX_EMDI_API MultiLegReportingType
            {
                enum Enum
                {
                    Undefined = -1,

                    SingleSecurity = 1,

                    IndividualLegOfMultiLegSecurity = 2,

                    MultiLegSecurity = 3
                };
            };

            struct ONIXS_EUREX_EMDI_API MultiLegPriceModel
            {
                enum Enum
                {
                    Undefined = -1,

                    Standard = 0,

                    UserDefined = 2
                };
            };
 

            struct ONIXS_EUREX_EMDI_API SoldOutIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    SoldOut = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API LastFragment
            {
                enum Enum
                {
                    Undefined = -1,

                    NotLastMessage = 0,

                    LastMessage,
                };
            };
 
            namespace EOBI
            {
                typedef Int64 QuantityType;
 
                struct ONIXS_EUREX_EMDI_API AggressorSide // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        Buy = 1,

                        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 RelatedPriceType // uint8_t
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Basis = 1,
                        CustomUnderlyingPrice = 2
                    };
 
                    static std::string toString (Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API TradingStyle // uint8_t
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Regular = 1,
                        TAC = 2,
                        TAM = 3,
                        MOC = 4,
                    };
 
                    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,
                        RetailAuction           = 205,
                    };
 
                    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,
 
                        ComplexInstrument           = 14,
                        TesTradeReport              = 15,
                        HhIndex                     = 16,
                        FlexibleInstrument          = 17,
                        ScaledSimpleInstrument      = 18
                    };
                };
 
                struct ONIXS_EUREX_EMDI_API MatchSubType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        OpeningAuction          = 1,
                        ClosingAuction          = 2,
                        IntradayAuction         = 3,
                        CircuitBreakerAuction   = 4,
                        IPOAuction              = 5,
                        RetailAuctionVolaTrade  = 6,
                    };
 
                    static std::string toString (Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API MatchType // UInt8
                {
                    enum Enum
                    {
                        NoValue                   = 0xFF,
                        Manual                    = 3,
                        Uncrossing                = 5,
                        Auction                   = 7,
                        LiquidityImprovementCross = 13,
                        ContinuousAuction         = 14
                    };
 
                    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,
 
                        SimpleInstrument = 1,
                        StandardOptionStrategy = 2,
                        NonStandardOptionStrategy = 3,
                        VolatilityStrategy = 4,
                        FuturesSpread   = 5,
                        InterProductSpread = 6,
                        StandardFuturesStrategy = 7,
                        PackAndBundle = 8,
                        Strip = 9,
                        FlexibleInstrument = 10,
                        CommodityStrip = 11,
                        ScaledSimpleInstrument = 12,
                        NonStandardVolatilityStrategy = 13,
                        TotalReturnFutureStrategy = 14
                    };
 
                    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,
                        KnockedOut  = 6,
                        KnockOutRevoked = 7,
                        Suspended   = 9,
                        PendingDeletion = 11,
                        KnockedOutAndSuspended = 12,
                    };
 
                    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,
                        Freeze                      = 216,
                        TradeAtClose                = 217,
                        RetailPreCall = 218,
                        RetailCall = 219,
                        CircuitBreakerAuctionTriggeredByStaticLimitBreach = 220,
                        CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze = 221,
                    };
 
                    static std::string toString (Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API SecurityType // String(4)
                {
                    enum Enum
                    {
                        NoValue  = 0,
                        Option   = 1, // OPT,
                        Future   = 2, // FUT,
                        MultiLeg = 3  // 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);
                };
 
                struct ONIXS_EUREX_EMDI_API CrossRequestType // UInt8
                {
                    enum Enum
                    {
                        Undefined = 0xFF,
                        CrossAnnouncement = 1,
                        LiquidityImprovementCross = 2,
                    };
 
                    static std::string toString (Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API InputSource // UInt8
                {
                    enum Enum
                    {
                        Undefined = 0xFF,
                        ClipClientBroker = 1,
                    };
 
                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradeCondition // UInt16
                {
                    enum Enum
                    {
                        NoValue      = 0xFFFF,
                        ImpliedTrade = 1,
                        OutOfSequence = 107,
                        MidpointPrice = 155,
                        TradingOnTermsOfIssue = 156,
                        SpecialAuction = 596,
                        TradeAtClose = 624,
                        Retail = 743,
                        AuctionVolumeDiscovery = 206,
                    };
 
                    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,
                        OutOfMainSessionTrading = 10
                    };
 
                    static std::string toString (Enum value);
                };
 
 
                struct ONIXS_EUREX_EMDI_API PotentialSecurityTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        None  = 0,

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

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

                        PriceVolatilityAuctionIsExtended = 10,

                        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 = 1,

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

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

                        Active = 1,

                        Inactive = 2,

                        Expired = 4,

                        KnockedOut = 6,

                        KnockOutRevoked = 7,

                        Suspended = 9,

                        PendingDeletion = 11,

                        KnockedOutAndSuspended = 12
                    };
 
                    static std::string toString(Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API SecurityMassTradingStatus // 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,

                        Freeze = 216,

                        TradeAtClose = 217,

                        RetailPreCall = 218,

                        RetailCall = 219,

                        CircuitBreakerAuctionTriggeredByStaticLimitBreach = 220,

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

                        Normal = 0,

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

                        PriceVolatilityAuctionIsExtended = 10,

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

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

                        N = 0,

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

                        Put = 0,

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

                        European = 0,

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

                        Cash = 0,

                        Physical = 1,
                    };
 
                    static std::string toString(Enum value);
                };
 
 
                struct ONIXS_EUREX_EMDI_API TrdType // UInt16
                {
                    enum Enum
                    {
                        NoValue = 0xFFFF,
 
                        BlockTrade = 1,
                        ExchangeForPhysical = 2,
                        EFS = 12,
                        PortfolioCompressionTrade = 50,
                        OTC = 54,
                        ExchangeBasisFacility = 55,
                        VolaTrade = 1000,
                        EFPFinTrade = 1001,
                        EFPIndexFuturesTrade = 1002,
                        BlockTradeAtMarket = 1004,
                        XetraEurexEnlightTriggeredTrade = 1006,
                        BlockQTPIPTrade = 1007,
                    };
 
                    static std::string toString(Enum value);
                };
 
                struct ONIXS_EUREX_EMDI_API MultiLegReportingType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        SingleSecurity = 1,

                        IndividualLeg = 2,

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

                        Standard = 0,

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

                        Book = 0,

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

                        Halted = 1,

                        Open = 2,

                        Closed = 3,

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

                        Active = 1,

                        Inactive = 2,

                        Expired = 4,

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

                        Active = 1,

                        Inactive = 2,

                        Expired = 4,

                        Suspended = 9,
                    };
 
                    static std::string toString(Enum value);
                };
 
            }
        }
    }
}