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
 
#include <OnixS/CboeCFE/Trading/BOE/Integral.h>
 
#include <string>
 
namespace OnixS {
namespace CboeCFE {
namespace Trading {
namespace BOE {

    struct OrderReasonCode
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Admin = 'A',

            UnknownMaturityDate = 'B',

            UnknownProductName = 'C',

            DuplicateIdentifier = 'D',

            Halted = 'H',

            IncorrectDataCenter = 'I',
            
            OrderRateThresholdExceeded = 'K',

            LiquidityAvailableExceedsOrderSize = 'M',

            RanOutOfLiquidityToExecuteAgainst = 'N',

            ClOrdIdDoesntMatchKnownOrder = 'O',

            CantModifyAnOrderThatIsPending = 'P',

            UserRequested = 'U',
            
            WouldWash = 'V',

            OrderExpired = 'X',

            SymbolNotSupported = 'Y',

            UnforeseenReason = 'Z',

            OrderPersisted = 'h',

            RiskManagementEfidLevelOrCustomGroupIdLevel = 'f',

            MarketAccessRiskLimitExceeded = 'm',

            RiskManagementConfigurationIsInsufficient = 'n',

            MaxOpenOrdersCountExceeded = 'o',

            RiskManagementProductLevel = 's',

            OrderReceivedByCfeDuringReplay = 'y',

            SessionEnd = 'z',

            OnlyCloseTransactionsAccepted = 'c'
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OrderReasonCode::Enum);

    inline std::string toStr(OrderReasonCode::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }
 

    struct QuoteReasonCode
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Success = ' ',

            InvalidEFID = 'C',

            InvalidWashId = 'D',

            NotEnabledForQuotes = 'F',

            IncorrectDataCenter = 'I',

            MessageRateThreshold = 'K',

            InvalidQuoteCnt = 'L',

            SymbolsNotOnSameMatchingEngine = 'M',

            InvalidManualOrderIndicator = 'O',

            InvalidQuoteUpdateID = 'Q',

            FuturesRootDoesNotMatchAcrossQuotes = 'R',

            SymbolNotFound = 'S',

            InvalidWashPreventType = 'W',

            Admin = 'a',

            InvalidCapacity = 'c',

            InvalidOEOID = 'e',

            RiskManagementEFIDorCustomGroupIDlevel = 'f',

            InvalidCtiCode = 'i',

            InvalidWashMethod = 'm',

            ExceedesMaxNotionalValuePerOrder = 'n',

            InvalidOpenOrClose = 'o',

            RiskManagementProductLevel = 'p',

            InvalidRemove = 'r',

            InvalidSide = 's',

            SymbolRangeUnreachable = 'u',

            ExceedesMaxSizePerOrder = 'x',

            QuoteReceivedByCfeDuringReplay = 'y',

            InvalidSizeModifier = 'z',

            CloseOnly = 'd'
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, QuoteReasonCode::Enum);

    inline std::string toStr(QuoteReasonCode::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct MessageType
    {
        typedef UInt8 Base;
        
        enum Enum
        {
            LoginRequest = 1,
            LogoutRequest = 2,
            ClientHeartbeat = 3,
 
            NewOrderV2 = 1008,
            ModifyOrder = 1002,
            CancelOrder = 1003,
            MassCancelOrder = 1004,
            PurgeOrders = 1005,
            QuoteUpdate = 1006,
            ResetRisk = 1007,
 
            LoginResponse = 501,
            ReplayComplete = 502,
            LogoutResponse = 503,
            ServerHeartbeat = 504,
 
            OrderAcknowledgement = 1501,
            OrderRejected = 1502,
            OrderModified = 1503,
            ModifyRejected = 1504,
            OrderExecution = 1505,
            OrderCancelled = 1506,
            CancelRejected = 1507,
            MassCancelAcknowledgement = 1508,
            MassCancelRejected = 1509,
            PurgeAcknowledgement = 1510,
            PurgeRejected = 1511,
            TradeCancelOrCorrect = 1512,
            TASRestatement = 1513,
            VarianceRestatement = 1514,
            QuoteUpdateAcknowledgement = 1515,
            QuoteUpdateRejected = 1516,
            QuoteRestated = 1517,
            QuoteExecution = 1518,
            QuoteCancelled = 1519,
            TASQuoteRestatement = 1520,
            VarianceQuoteRestatement = 1521,
            ResetRiskAcknowledgement = 1522,
            NewComplexInstrumentAccepted = 1526,
            NewComplexInstrumentRejected = 1527,
 
            NewOrderOptionUSFutures = 1009,
            QuoteUpdateOptionUSFutures = 1010,
            OrderAcknowledgementOptionUSFutures = 1523,
            OrderExecutionOptionUSFutures = 1524,
            TradeCancelCorrectOptionUSFutures = 1525,
            NewComplexInstrument = 1011,
 
            Undefined = 0xFFFF
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, MessageType::Enum);

    inline std::string toStr(MessageType::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct BaseLiquidityIndicator
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            AddedLiquidity = 'A',

            RemovedLiquidity = 'R',

            MarketOpening = 'C',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, BaseLiquidityIndicator::Enum);

    inline std::string toStr(BaseLiquidityIndicator::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct CancelOrigOnReject
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            LeaveOriginalOrderAlone = 'N',

            CancelOriginalOrderIfModificationFails = 'Y',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CancelOrigOnReject::Enum);

    inline std::string toStr(CancelOrigOnReject::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct Capacity
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Customer = 'C',

            Firm = 'F',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, Capacity::Enum);

    inline std::string toStr(Capacity::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct CtiCode
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Cti1 = '1',

            Cti2 = '2',

            Cti3 = '3',

            Cti4 = '4',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CtiCode::Enum);

    inline std::string toStr(CtiCode::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct CustOrderHandlingInst
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Desk = 'W',

            Electronic = 'Y',

            VendorProvidedPlatform = 'C',

            SponsoredAccessViaExchangeApiOrFix = 'G',

            PremiumAlgorithmicTradingProvider = 'H',

            Other = 'D',

            ApplyPortDefault = 0
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CustOrderHandlingInst::Enum);

    inline std::string toStr(CustOrderHandlingInst::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct ManualOrderIndicator
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Manual = 'Y',

            Automated = 'N',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, ManualOrderIndicator::Enum);

    inline std::string toStr(ManualOrderIndicator::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct MultilegReportingType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            SimpleInstrumentExecution = '1',

            SimpleInstrumentExecutionThatIsPartOfSpreadExecution = '2',

            SpreadInstrumentExecution = '3',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, MultilegReportingType::Enum);

    inline std::string toStr(MultilegReportingType::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct OpenClose
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Open = 'O',

            Close = 'C',

            None = 'N',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OpenClose::Enum);

    inline std::string toStr(OpenClose::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct OrdType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Market = '1',

            Limit = '2',

            StopLimit = '4',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OrdType::Enum);

    inline std::string toStr(OrdType::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct PendingStatus
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            NotApplicable = 'N',

            Pending = 'P',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, PendingStatus::Enum);

    inline std::string toStr(PendingStatus::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct QuoteResult
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            NewQuote = 'A',

            ModifiedLossOfPriority = 'L',

            ModifiedRetainsPriority = 'R',

            NoChangeMatchesExistingQuote = 'N',

            NewQuoteButMayRemoveLiquidity = 'D',

            Modified = 'd',

            UserCancelled = 'U',

            Admin = 'a',

            RejectedCantPost = 'P',

            RiskManagementEFIDorCustomGroupIdLevel = 'f',

            RejectedSymbolNotFound = 'S',

            RejectedInvalidPrice = 'p',

            RiskManagementProductRootLevel = 's',

            RiskManagementConfigurationIsInsuffcient = 'n',

            RejectedOtherReason = 'u'
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, QuoteResult::Enum);

    inline std::string toStr(QuoteResult::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct RestatementReason
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Liquidity = 'Q',

            Wash = 'W',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, RestatementReason::Enum);

    inline std::string toStr(RestatementReason::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct RiskResetResult
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Ignored = ' ',

            Success = 'Y',

            RejectedExceedsFirmResetLimit = 'F',

            RejectedExceedsCustomGroupIdlimit = 'C',

            RejectedEmptyResetRiskField = 'E',

            RejectedIncorrectDataCenter = 'I',

            RejectedExceedsProductLevelResetLimit = 'S',

            RejectedInvalidRiskRoot = 'U',

            RejectedInvalidEFIDorClearingFirm = 'c',

            RejectedInReplay = 'y'
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, RiskResetResult::Enum);

    inline std::string toStr(RiskResetResult::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct Side
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Buy = '1',

            Sell = '2',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, Side::Enum);

    inline std::string toStr(Side::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct SizeModifier
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Null = 0,

            Reduce = 'R',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, SizeModifier::Enum);

    inline std::string toStr(SizeModifier::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct SubLiquidityIndicator
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            NoAdditionalInformation = 0,

            CarriedOrderIndicator = 'C',

            QualifyingMarketTurnerOrder = 'U'
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, SubLiquidityIndicator::Enum);

    inline std::string toStr(SubLiquidityIndicator::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct TimeInForce
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Day = '0',

            GTC = '1',

            IOC = '3',

            FOK = '4',

            GTD = '6',
        };
    };

    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, TimeInForce::Enum);

    inline std::string toStr(TimeInForce::Enum value)
    {
        std::string str;
 
        toStr(str, value);
 
        return str;
    }

    struct LoginResponseStatus
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Accepted = 'A',
            SessionInUse = 'B',
            Disabled = 'D',
            InvalidUnit = 'I',
            InvalidMessage = 'M',
            NotAuthorized = 'N',
            SequenceAhead = 'Q',
            InvalidSession = 'S',
        };
    };
 
    ONIXS_CBOE_CFE_BOE_DECLARE_T0_STR_FUNCTIONS(LoginResponseStatus::Enum)
 
    
    struct LogoutResponseReason
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            UserRequested     = 'U',
            Administrative    = 'A',
            ProtocolViolation = '!',
        };
    };
 
    ONIXS_CBOE_CFE_BOE_DECLARE_T0_STR_FUNCTIONS(LogoutResponseReason::Enum)
 
}
}
}
}