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 <string> 
 
#include <OnixS/eSpeed/MarketData/Itch/Integral.h>
 
ONIXS_ESPEED_ITCH_NAMESPACE_BEGIN
 

    struct MessageType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            OrderBookDirectory = 'R',

            CombinationOrderBookDirectory = 'M',

            SystemEvent = 'S',

            OrderBookState = 'O',

            AddOrder = 'A',

            OrderExecuted = 'E',

            OrderExecutedWithPrice = 'C',

            OrderCancel = 'X',

            Trade = 'P',

            ExecutionDone = 'D',

            Information = 'Q',

            BrokenTrade = 'B',
 
        };
    };

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

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

    struct SystemEventCode
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            StartOfMessages = 'O',

            StartOfTradingSessionHours = 'Q',

            EndOfTradingSessionHours = 'M',

            EndOfMessages = 'C',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, SystemEventCode::Enum);

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

    struct SystemEventReason
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            AcceptingHolidaySessionStarts = 'I',

            Break = 'A',

            ResumptionAfterBreak = 'B',

            EarlyClose = 'H',

            RegularStartOrEnd = 'R',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, SystemEventReason::Enum);

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

    struct SecurityEventCode
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Enabled = 'O',

            Disabled = 'M',

            Halted = 'H',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, SecurityEventCode::Enum);

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

    struct ProductType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            USTreasury = 1,

            USTreasuryBills = 2,

            Reserved3 = 3,

            TIPS = 4,

            Reserved5 = 5,

            CurveOrButterflies = 6,
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, ProductType::Enum);

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

    struct ProductSubType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Benchmark = 1,

            OffTheRun = 2,

            WI = 3,
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, ProductSubType::Enum);

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

    struct PriceType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            PerUnit = 'D',

            AsPercentage = 'Y',

            YieldSpread = 'B',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, PriceType::Enum);

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

    struct TradingFeatures
    {
        typedef UInt16 Base;
 
        enum Enum
        {
            Reserved1 = 0x0001,

            SecuritySupportsImpliedTradingThroughLegs = 0x0002,

            IndicativeMarketsSupported = 0x0004,

            Reserved2 = 0x0008,

            TestSecurity = 0x8000,

            NonTradableSecurity = 0x4000,
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, TradingFeatures::Enum);

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

    struct LegSide
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            Undefined = ' ',

            AsDefined = 'B',

            Opposite = 'C',

            LockPriceForTreasurySwap = 'L',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, LegSide::Enum);

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

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

            Sell = 'S',
 
        };
    };

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

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

    struct Printable
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            No = 'N',

            Yes = 'Y',
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, Printable::Enum);

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

    struct IssuedAsBenchmark
    {
        typedef UInt16 Base;
 
        enum Enum
        {
            Undefined = 0,

            Issued1M = 1,

            Issued2M = 2,

            Issued3M = 3,

            Issued6M = 6,

            Issued12M = 12,

            Issued2Y = 102,

            Issued3Y = 103,

            Issued5Y = 105,

            Issued7Y = 107,

            Issued10Y = 110,

            Issued20Y = 120,

            Issued30Y = 130,
 
        };
    };

    ONIXS_ESPEED_ITCH_API void toStr(std::string&, IssuedAsBenchmark::Enum);

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