Enumerations.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
 
// Project specific includes
#include <OnixS/Eurex/DropCopy/Export.h>
 
// Standard includes
#include <iosfwd>
#include <string>
 
namespace OnixS { namespace Eurex { namespace DropCopy {

struct ONIXS_EUREX_EDCI_EXPORT ApplId
{
    enum Enum
    {
        NoValue = 0xFF,     
        OrderDropCopy = 12, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ApplId::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ApplId::Enum);

struct ONIXS_EUREX_EDCI_EXPORT ApplSeqIndicator
{
    enum Enum
    {
        NoValue = 0xFF,         
        NoRecoveryRequired = 0, 
        RecoveryRequired = 1,   
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ApplSeqIndicator::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ApplSeqIndicator::Enum);

struct ONIXS_EUREX_EDCI_EXPORT CrossMatchInstruction
{
    enum Enum
    {
        NoValue = 0xFF,                 
        CancelAggressive = 1,           
        CancelPassive = 2,              
        CancelAggressiveAndPassive = 3, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(CrossMatchInstruction::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, CrossMatchInstruction::Enum);

struct ONIXS_EUREX_EDCI_EXPORT CrossedIndicator
{
    enum Enum
    {
        NoValue = 0xFF,    
        NoCrossing = 0,    
        CrossRejected = 1, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(CrossedIndicator::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, CrossedIndicator::Enum);

struct ONIXS_EUREX_EDCI_EXPORT CustOrderHandlingInst
{
    enum Enum
    {
        NoValue = 0x00, 
        W = 'W',        
        Y = 'Y',        
        C = 'C',        
        G = 'G',        
        H = 'H',        
        D = 'D',        
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(CustOrderHandlingInst::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, CustOrderHandlingInst::Enum);

struct ONIXS_EUREX_EDCI_EXPORT ExecInst
{
    enum Enum
    {
        NoValue = 0xFF, 
        H = 1,          
        Q = 2,          
        H6 = 5,         
        Q6 = 6,         
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ExecInst::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ExecInst::Enum);

struct ONIXS_EUREX_EDCI_EXPORT ExecType
{
    enum Enum
    {
        NoValue = 0x00,       
        New = '0',            
        Canceled = '4',       
        Replaced = '5',       
        PendingCancelE = '6', 
        Suspended = '9',      
        Restated = 'D',       
        Triggered = 'L',      
        Trade = 'F',          
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ExecType::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ExecType::Enum);

struct ONIXS_EUREX_EDCI_EXPORT ExecutingTraderQualifier
{
    enum Enum
    {
        NoValue = 0xFF, 
        Algo = 22,      
        Human = 24,     
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ExecutingTraderQualifier::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ExecutingTraderQualifier::Enum);

struct ONIXS_EUREX_EDCI_EXPORT LastFragment
{
    enum Enum
    {
        NoValue = 0xFF,     
        NotLastMessage = 0, 
        LastMessage = 1,    
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(LastFragment::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, LastFragment::Enum);

struct ONIXS_EUREX_EDCI_EXPORT MarketId
{
    enum Enum
    {
        NoValue = 0xFFFF, 
        XEUR = 1,         
        XEEE = 2,         
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(MarketId::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, MarketId::Enum);

struct ONIXS_EUREX_EDCI_EXPORT MatchType
{
    enum Enum
    {
        NoValue = 0xFF,                 
        AutoMatchIncoming = 4,          
        CrossAuction = 5,               
        CallAuction = 7,                
        AutoMatchResting = 11,          
        LiquidityImprovementCross = 13, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(MatchType::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, MatchType::Enum);

struct ONIXS_EUREX_EDCI_EXPORT OrdStatus
{
    enum Enum
    {
        NoValue = 0x00,        
        New = '0',             
        PartiallyFilled = '1', 
        Filled = '2',          
        Canceled = '4',        
        PendingCancel = '6',   
        Suspended = '9',       
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(OrdStatus::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, OrdStatus::Enum);

struct ONIXS_EUREX_EDCI_EXPORT OrdType
{
    enum Enum
    {
        NoValue = 0xFF, 
        Market = 1,     
        Limit = 2,      
        Stop = 3,       
        StopLimit = 4,  
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(OrdType::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, OrdType::Enum);

struct ONIXS_EUREX_EDCI_EXPORT OrderOrigination
{
    enum Enum
    {
        NoValue = 0xFF,                
        DirectAccessCustomer = 5,      
        SponsoredAccessCustomer = 105, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(OrderOrigination::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, OrderOrigination::Enum);

struct ONIXS_EUREX_EDCI_EXPORT PartyIdInvestmentDecisionMakerQualifier
{
    enum Enum
    {
        NoValue = 0xFF, 
        Algo = 22,      
        Human = 24,     
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(PartyIdInvestmentDecisionMakerQualifier::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdInvestmentDecisionMakerQualifier::Enum);

struct ONIXS_EUREX_EDCI_EXPORT ProductComplex
{
    enum Enum
    {
        NoValue = 0xFF,                     
        SimpleInstrument = 1,               
        StandardOptionStrategy = 2,         
        NonStandardOptionStrategy = 3,      
        VolatilityStrategy = 4,             
        FuturesSpread = 5,                  
        InterProductSpread = 6,             
        StandardFutureStrategy = 7,         
        PackAndBundle = 8,                  
        Strip = 9,                          
        NonStandardVolatilityStrategy = 13, 
        TotalReturnFutureStrategy = 14,     
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(ProductComplex::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, ProductComplex::Enum);

struct ONIXS_EUREX_EDCI_EXPORT SelfMatchPreventionInstruction
{
    enum Enum
    {
        NoValue = 0xFF,            
        CrossRejectedBU = 100,     
        CrossRejectedMarket = 101, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(SelfMatchPreventionInstruction::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, SelfMatchPreventionInstruction::Enum);

struct ONIXS_EUREX_EDCI_EXPORT SessionMode
{
    enum Enum
    {
        NoValue = 0xFF, 
        ETIHF = 1,      
        ETILF = 2,      
        GUI = 3,        
        FIXLF = 4,      
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(SessionMode::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, SessionMode::Enum);

struct ONIXS_EUREX_EDCI_EXPORT SessionRejectReason
{
    enum Enum
    {
        NoValue = 0xFFFFFFFF,                       
        RequiredTagMissing = 1,                     
        ValueIsIncorrect = 5,                       
        DecryptionProblem = 7,                      
        InvalidMsgID = 11,                          
        IncorrectNumInGroupCount = 16,              
        Other = 99,                                 
        ExposureLimitExceeded = 101,                
        ServiceNotAvailable = 103,                  
        OutboundConversionError = 105,              
        HeartbeatViolation = 152,                   
        InternalTechnicalError = 200,               
        ValidationError = 210,                      
        SessionLoginLimitReached = 217,             
        OutstandingLoginsBuLimitReached = 226,      
        OutstandingLoginsSessionLimitReached = 227, 
        PasswordTimestampNotInGracePeriod = 228,    
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(SessionRejectReason::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, SessionRejectReason::Enum);

struct ONIXS_EUREX_EDCI_EXPORT SessionStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Active = 0,     
        Logout = 4,     
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(SessionStatus::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, SessionStatus::Enum);

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

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(Side::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, Side::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TimeInForce
{
    enum Enum
    {
        NoValue = 0xFF, 
        Day = 0,        
        GTC = 1,        
        IOC = 3,        
        FOK = 4,        
        GTD = 6,        
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TimeInForce::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TimeInForce::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TradSesEvent
{
    enum Enum
    {
        NoValue = 0xFF,              
        EndOfRestatement = 103,      
        EndOfDayService = 104,       
        EndOfOrderBookSynch = 107,   
        StartOfOrderBookSynch = 108, 
        OrderBookReset = 109,        
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TradSesEvent::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TradSesEvent::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TradSesMode
{
    enum Enum
    {
        NoValue = 0xFF,       
        Testing = 1,          
        Simulated = 2,        
        Production = 3,       
        Acceptance = 4,       
        DisasterRecovery = 5, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TradSesMode::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TradSesMode::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TradingCapacity
{
    enum Enum
    {
        NoValue = 0xFF,  
        Customer = 1,    
        Principal = 5,   
        MarketMaker = 6, 
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TradingCapacity::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TradingCapacity::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TradingSessionSubId
{
    enum Enum
    {
        NoValue = 0xFF,     
        OpeningAuction = 2, 
        ClosingAuction = 4, 
        AnyAuction = 8,     
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TradingSessionSubId::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TradingSessionSubId::Enum);

struct ONIXS_EUREX_EDCI_EXPORT Triggered
{
    enum Enum
    {
        NoValue = 0xFF,    
        NotTriggered = 0,  
        TriggeredStop = 1, 
        TriggeredOCO = 2,  
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(Triggered::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, Triggered::Enum);

struct ONIXS_EUREX_EDCI_EXPORT TemplateId
{
    enum Enum
    {
        Unknown = 0,                       
        DeleteOrderBroadcast = 10902,      
        ForcedLogoutNotification = 10012,  
        Heartbeat = 10011,                 
        HeartbeatNotification = 10023,     
        LogonRequest = 10000,              
        LogonResponse = 10001,             
        LogoutRequest = 10002,             
        LogoutResponse = 10003,            
        OrderExecReportBroadcast = 10901,  
        PartitionListNotification = 10037, 
        Reject = 10010,                    
        SessionListNotification = 10036,   
        SessionStatusBroadcast = 10903,    
    };
};

ONIXS_EUREX_EDCI_EXPORT std::string enumToString(TemplateId::Enum);

ONIXS_EUREX_EDCI_EXPORT std::ostream& operator<<(std::ostream&, TemplateId::Enum);
 
}}} // namespace OnixS::Eurex::DropCopy