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 {

    /// Order Reason Code
    struct OrderReasonCode
    {
        /// Integral type used as basement for constants. 
        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'
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OrderReasonCode::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(OrderReasonCode::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }


    /// Quote Reason Code
    struct QuoteReasonCode
    {
        /// Integral type used as basement for constants. 
        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'
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, QuoteReasonCode::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(QuoteReasonCode::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Message types
    struct MessageType
    {
        /// Integral type used as basement for constants. 
        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,

            NewOrderOptionUSFutures = 1009,
            QuoteUpdateOptionUSFutures = 1010,
            OrderAcknowledgementOptionUSFutures = 1523,
            OrderExecutionOptionUSFutures = 1524,
            TradeCancelCorrectOptionUSFutures = 1525,

            Undefined = 0xFFFF
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, MessageType::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(MessageType::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// BaseLiquidityIndicator
    struct BaseLiquidityIndicator
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Added Liquidity 
            AddedLiquidity = 'A',

            /// Removed Liquidity 
            RemovedLiquidity = 'R',

            /// Market opening / re-opening trade
            MarketOpening = 'C',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, BaseLiquidityIndicator::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(BaseLiquidityIndicator::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// CancelOrigOnReject
    struct CancelOrigOnReject
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Leave original order alone.
            LeaveOriginalOrderAlone = 'N',

            /// Cancel original order if modification fails
            CancelOriginalOrderIfModificationFails = 'Y',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CancelOrigOnReject::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(CancelOrigOnReject::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Capacity
    struct Capacity
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Customer
            Customer = 'C',

            /// Firm
            Firm = 'F',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, Capacity::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(Capacity::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// CTI codes
    struct CtiCode
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Transactions initiated and executed by an individual TPH for the TPH�s own account, for an account the TPH
            /// controls, or for the account in which the TPH has an ownership or financial interest.
            Cti1 = '1',

            /// Transactions executed for the proprietary account of a clearing TPH or non - clearing TPH.
            Cti2 = '2',

            /// Transactions where an individual TPH or authorized trader executes for the personal account of another individual
            /// TPH, for an account the other individual TPH controls or for an account in which the other individual TPH has an ownership or financial interest.
            Cti3 = '3',

            /// Any transaction not meeting the definition of CTI 1, 2 or 3. (These should be non - TPH customer transactions).
            Cti4 = '4',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CtiCode::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(CtiCode::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Execution source code provided during order entry to describe broker service.
    struct CustOrderHandlingInst
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            ///
            Desk = 'W',

            ///
            Electronic = 'Y',

            ///
            VendorProvidedPlatform = 'C',

            ///
            SponsoredAccessViaExchangeApiOrFix = 'G',

            ///
            PremiumAlgorithmicTradingProvider = 'H',

            ///
            Other = 'D',

            ///
            ApplyPortDefault = 0
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, CustOrderHandlingInst::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(CustOrderHandlingInst::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Manual Order Indicators
    struct ManualOrderIndicator
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Manual order entry
            Manual = 'Y',

            /// Automated order entry
            Automated = 'N',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, ManualOrderIndicator::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(ManualOrderIndicator::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// MultilegReportingType
    struct MultilegReportingType
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Simple instrument execution 
            SimpleInstrumentExecution = '1',

            /// Simple instrument execution that is part of a Spread execution
            SimpleInstrumentExecutionThatIsPartOfSpreadExecution = '2',

            /// Spread instrument execution
            SpreadInstrumentExecution = '3',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, MultilegReportingType::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(MultilegReportingType::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Indicates status of client position in a trade resulting from the order
    struct OpenClose
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Open
            Open = 'O',

            /// Close
            Close = 'C',

            /// None
            None = 'N',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OpenClose::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(OpenClose::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Order types.
    struct OrdType
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Market
            Market = '1',

            /// Limit
            Limit = '2',

            /// Stop Limit
            StopLimit = '4',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, OrdType::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(OrdType::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// PendingStatus
    struct PendingStatus
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Not applicable
            NotApplicable = 'N',

            /// Pending 
            Pending = 'P',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, PendingStatus::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(PendingStatus::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// QuoteResult.
    struct QuoteResult
    {
        /// Integral type used as basement for constants. 
        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'
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, QuoteResult::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(QuoteResult::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Restatement Reasons.
    struct RestatementReason
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Liquidity
            Liquidity = 'Q',

            /// Wash
            Wash = 'W',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, RestatementReason::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(RestatementReason::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// RiskResetResult.
    struct RiskResetResult
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            ///
            Ignored = ' ',

            ///
            Success = 'Y',

            /// 
            RejectedExceedsFirmResetLimit = 'F',

            /// 
            RejectedExceedsCustomGroupIdlimit = 'C',

            ///
            RejectedEmptyResetRiskField = 'E',

            ///
            RejectedIncorrectDataCenter = 'I',

            ///
            RejectedExceedsProductLevelResetLimit = 'S',

            ///
            RejectedInvalidRiskRoot = 'U',

            ///
            RejectedInvalidEFIDorClearingFirm = 'c',

            ///
            RejectedInReplay = 'y'
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, RiskResetResult::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(RiskResetResult::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Order sides.
    struct Side
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Buy side
            Buy = '1',

            /// Sell side
            Sell = '2',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, Side::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(Side::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// SizeModifier.
    struct SizeModifier
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            ///New quote size will be set to value of OrderQty.
            Null = 0,

            ///Reduce outstanding size of quote by the OrderQty provided.
            Reduce = 'R',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, SizeModifier::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(SizeModifier::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// SubLiquidityIndicator
    struct SubLiquidityIndicator
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// No Additional Information
            NoAdditionalInformation = 0,

            /// Carried Order Indicator 
            CarriedOrderIndicator = 'C',

            /// Qualifying Market Turner order
            QualifyingMarketTurnerOrder = 'U'
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, SubLiquidityIndicator::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(SubLiquidityIndicator::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Time in force
    struct TimeInForce
    {
        /// Integral type used as basement for constants. 
        typedef UInt8 Base;

        enum Enum
        {
            /// Day (Expires at the end of the business day)
            Day = '0',

            /// GTC (Good �till Cancel.Order remains until cancelled or contract expires)
            GTC = '1',

            /// IOC (Portion not filled immediately is cancelled. Market orders are implicitly IOC)
            IOC = '3',

            /// FOK (An IOC where the entire size must be filled, else the order will be cancelled back)
            FOK = '4',

            /// GTD (Good ‘till Date-Time Expires at the date-time specified in the ExpireTime field).
            GTD = '6',
        };
    };

    /// Appends string presentation of object.
    ONIXS_CBOE_CFE_BOE_API void toStr(std::string&, TimeInForce::Enum);

    /// Returns string presentation of object.
    inline std::string toStr(TimeInForce::Enum value)
    {
        std::string str;

        toStr(str, value);

        return str;
    }

    /// Login status
    struct LoginResponseStatus
    {
        /// Integral type used as basement for constants.
        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
    {
        /// Integral type used as basement for constants.
        typedef UInt8 Base;

        enum Enum
        {
            UserRequested     = 'U',
            Administrative    = 'A',
            ProtocolViolation = '!',
        };
    };

    ONIXS_CBOE_CFE_BOE_DECLARE_T0_STR_FUNCTIONS(LogoutResponseReason::Enum)

}
}
}
}