Enumerations.h

Go to the documentation of this file.

#pragma once
/*
* 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.
*/
#include <string> 
 
#include <OnixS/LSE/MarketData/GTP/Defines.h>
 
 
namespace OnixS {
namespace LSE {
namespace MarketData {
namespace GTP {
 

    struct EventCode
    {
        typedef Byte Base;
 
        enum Enum
        {
            EndOfDay = 'C',

            StartOfDay = 'O',

            StartOfOpen = 'T',

            StartOfPreClose = 'P',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, EventCode::Enum);

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

    struct SettlementSystem
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            RRG = 1,

            ExpressI = 2,

            ExpressII = 3,

            Clearstream = 4,

            Undefinedvalue = 5,

            T2S = 6,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, SettlementSystem::Enum);

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

    struct ClearingType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            NotCleared = 0,

            Cleared = 1,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, ClearingType::Enum);

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

    struct UnderlyingType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            UnderlyingTypeIsNotCodifiedInBasicData = 0,

            Share = 1,

            ForeignCurrency = 2,

            Indices = 3,

            Commodity = 4,

            ForeignIndices = 5,

            Future = 6,

            ForeignShare = 7,

            Basket = 8,

            ExchangeRate = 9,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, UnderlyingType::Enum);

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

    struct InstrumentOptionStyle
    {
        typedef Byte Base;
 
        enum Enum
        {
            EuropeanOptionStyle = 'E',

            AmericanOptionStyle = 'A',

            PeriodicOptionStyle = 'P',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, InstrumentOptionStyle::Enum);

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

    struct DirtyCleanPrice
    {
        typedef Byte Base;
 
        enum Enum
        {
            Unspecified = 0,

            Secco = 1,

            TelQuel = 2,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, DirtyCleanPrice::Enum);

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

    struct GrossSettlementIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            GrossSettlement = 'Y',

            NetNonGrossSettlement1 = 'N',

            NetNonGrossSettlement2 = ' ',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, GrossSettlementIndicator::Enum);

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

    struct InverseOrderbook
    {
        typedef Byte Base;
 
        enum Enum
        {
            No = 0,

            Yes = 1,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, InverseOrderbook::Enum);

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

    struct SessionChangeReason
    {
        typedef Byte Base;
 
        enum Enum
        {
            ScheduledTransition = 0,

            ExtendedbyMarketOps = 1,

            ShortenedbyMarketOps = 2,

            MarketOrderImbalance = 3,

            PriceOutsideRange = 4,

            AespCircuitBreakerTripped = 5,

            SpecialistNotPresent = 6,

            Unavailable = 9,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, SessionChangeReason::Enum);

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

    struct OrderType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            LimitOrderFirmQuote = 0,

            MarketOrder = 1,

            ImpliedOrder = 2,

            NamedLimit = 3,

            NamedMarket = 4,

            ExecutableQuotes = 5,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, OrderType::Enum);

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

    struct TradeType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            RegularTrade = 0,

            AuctionTradeBulk = 1,

            AuctionTradeIndividual = 2,

            LateTrade = 5,

            Reserve = 8,

            TradeCancellation = 9,

            StrategyVsStrategyTrade = 10,

            TradeCorrection = 11,

            RfqTrade = 22,

            RfqTradeCancellation = 23,

            RfqTradeCorrection = 24,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, TradeType::Enum);

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

    struct AuctionType
    {
        typedef Byte Base;
 
        enum Enum
        {
            Undefined = 0,

            ClosingAuction = 'C',

            OpeningAuction = 'O',

            AESP = 'A',

            EDSP = 'B',

            OPA = 'P',

            ResumeAuction = 'E',

            PeriodicAuction = 'F',

            IntradayLevel1Auction = 'G',

            FrequentLitAuctions = 'L',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, AuctionType::Enum);

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

    struct StatisticType
    {
        typedef UInt16 Base;
 
        enum Enum
        {
            IndicativeAuctionUncrossingData = 1,

            OfficialOpeningPrice = 2,

            OfficialClosingPrice = 3,

            TradeHighOnBook = 4,

            TradeLowOnBook = 5,

            TradeHighAllTrades = 6,

            TradeLowAllTrades = 7,

            Week52TradeHighAllTrades = 8,

            Week52TradeLowAllTrades = 9,

            BestClosingBid = 10,

            BestClosingAsk = 11,

            StaticReferencePrice = 16,

            DynamicReferencePrice = 17,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, StatisticType::Enum);

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

    struct AuctionInfo
    {
        typedef Byte Base;
 
        enum Enum
        {
            Undefined = 0,

            BuyImbalance = 'B',

            NoImbalance = 'N',

            InsufficientOrdersforAuction = 'O',

            SellImbalance = 'S',

            CallMarket = 'M',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, AuctionInfo::Enum);

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

    struct AnnouncementType
    {
        typedef Byte Base;
 
        enum Enum
        {
            Regular = '0',

            HighPriority = '1',

            LowPriority = '2',

            StressedMarketConditionStart = '3',

            StressedMarketConditionEnd = '4',

            StressedMarketObligationsStart = '5',

            StressedMarketObligationsEnd = '6',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, AnnouncementType::Enum);

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

    struct OrderBookType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            AllBooks = 0,

            FirmQuote = 1,

            OffBook = 2,

            Electronic = 3,

            PrivateRFQ = 4,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, OrderBookType::Enum);

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

    struct SourceVenue
    {
        typedef UInt16 Base;
 
        enum Enum
        {
            LondonStockExchange = 1,

            BorsaItalianaCashEquitiesAndFixedIncome = 2,

            BorsaItalianaDerivatives = 3,

            TurquoiseLit = 5,

            TurquoisePlato = 6,

            BorsaItalianaTradingAfterHours = 8,

            EuroTLX = 10,

            TRADEcho = 11,

            TurquoisePlatoLitAuctions = 12,

            TurquoiseCashOrderBook = 13,

            TurquoiseLitOrderBookTGHE = 14,

            TurquoisePlatoOrderBookTGHE = 15,

            TurquoisePlatoLitAuctionsOrderBookTGHE = 16,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, SourceVenue::Enum);

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

    struct VenueOfExecution
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            XLON = 21,

            XLOM = 22,

            AIMX = 23,

            XPVT = 24,

            XLOX = 25,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, VenueOfExecution::Enum);

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

    struct TradingStatus
    {
        typedef Byte Base;
 
        enum Enum
        {
            None = 0,

            Halt = 'H',

            HaltMatchingPartitionSuspended = 'J',

            HaltSystemSuspended = 'K',

            RegularTradingStartTradeReporting = 'T',

            HaltRegulatory = 'P',

            EndTradeReporting = 't',

            OpeningAuctionCall = 'a',

            PostClose = 'b',

            Closed = 'c',

            ClosingAuctionCall = 'd',

            AESPAuctionCall = 'e',

            ResumeAuction = 'f',

            PreMandatory = 'm',

            Mandatory = 'n',

            PostMandatory = 'o',

            EDSPAuctionCall = 'q',

            PeriodicAuctionCall = 'r',

            PreTrading = 'y',

            IntradayLevel1AuctionCall = 'G',

            Inactive = '1',

            Suspended = '2',

            NoActiveSession = 'w',

            EndOfPostClose = 'x',

            ClosingPriceCrossingSession = 'u',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, TradingStatus::Enum);

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

    struct ImbalanceDirection
    {
        typedef Byte Base;
 
        enum Enum
        {
            BuyImbalance = 'B',

            NoImbalance = 'N',

            InsufficientOrdersForAuction = 'O',

            SellImbalance = 'S',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, ImbalanceDirection::Enum);

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

    struct CrossType
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            InternalCross = 5,

            InternalBTF = 6,

            CommittedCross = 7,

            CommittedBTF = 8,

            EG1 = 9,

            EG2 = 10,

            ExchangeforPhysical = 11,

            BasisTrade = 12,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, CrossType::Enum);

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

    struct HiddenExecutionIndicator
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            None = 0,

            Visible = 1,

            Hidden = 2,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, HiddenExecutionIndicator::Enum);

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

    struct TradeQualifier
    {
        typedef Byte Base;
 
        enum Enum
        {
            None = ' ',

            ClosingPriceCross = 'C',

            CPX = 'T',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, TradeQualifier::Enum);

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

    struct MarketMechanism
    {
        typedef UInt8 Base;
 
        enum Enum
        {
            CentralLimitOrderBook = 1,

            QuoteDrivenMarketF = 2,

            DarkOrderBook = 3,

            OffBook = 4,

            PeriodicAuction = 5,

            RequestForAuction = 6,

            Other = 7,
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, MarketMechanism::Enum);

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

    struct TradingMode
    {
        typedef Byte Base;
 
        enum Enum
        {
            UndefinedAuction = '1',

            ScheduledOpeningAuction = 'O',

            ScheduledClosingAuction = 'K',

            ScheduledIntradayAuction = 'I',

            UnscheduledAuction = 'U',

            ContinuousTrading = '2',

            AtMarketCloseTrading = '3',

            OutOfMainSessionTrading = '4',

            OnExchange = '5',

            OffExchange = '6',

            SystemicInternaliser = '7',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, TradingMode::Enum);

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

    struct TransactionCategory
    {
        typedef Byte Base;
 
        enum Enum
        {
            DarkTrade = 'D',

            TradeThatHasReceivedPriceImprovement = 'R',

            PackageTrade = 'Z',

            ExchangeForPhysicalsTrade = 'Y',

            None = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, TransactionCategory::Enum);

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

    struct NegotiationIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            NegotiatedTrade = 'N',

            NegotiatedTradeLiquidFinancialInstruments = '1',

            NegotiatedradeIlliquidFinancialInstruments = '2',

            NegotiatedTradeSubjectToConditions = '3',

            NotNegotiatedTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, NegotiationIndicator::Enum);

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

    struct AgencyCrossIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            AgencyCrossTrade = 'X',

            NoAgencyCrossTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, AgencyCrossIndicator::Enum);

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

    struct ModificationIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            TradeCancellation = 'C',

            TradeAmendment = 'A',

            NewTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, ModificationIndicator::Enum);

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

    struct ReferencePriceIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            BenchmarkTrade = 'B',

            ReferencePriceTrade = 'S',

            MarketClosingPriceTrade = '1',

            NotReferencePriceTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, ReferencePriceIndicator::Enum);

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

    struct SpecialDividendIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            SpecialDividendTrade = 'E',

            NoSpecialDividendTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, SpecialDividendIndicator::Enum);

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

    struct OffBookAutomatedIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            OffBookNonAutomated = 'M',

            OffBookAutomated = 'Q',

            Unspecified = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, OffBookAutomatedIndicator::Enum);

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

    struct PriceFormationIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            PlainVanillaTrade = 'P',

            NonPriceFormingTrade = 'T',

            TradeNotContributingToPriceDiscovery = 'J',

            PendingPrice = 'N',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, PriceFormationIndicator::Enum);

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

    struct AlgorithmicIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            AlgorithmicTrade = 'H',

            NotAnAlgorithmicTrade = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, AlgorithmicIndicator::Enum);

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

    struct PostTradeDeferralReason
    {
        typedef Byte Base;
 
        enum Enum
        {
            LargeInScale = '2',

            IlliquidInstrument = '3',

            SizeSpecific = '4',

            LargeInScaleAndSizeSpecific = '5',

            LargeInScaleAndLargeInScale = '6',

            Immediate = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, PostTradeDeferralReason::Enum);

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

    struct DeferralEnrichmentType
    {
        typedef Byte Base;
 
        enum Enum
        {
            LMTF = '1',

            DATF = '2',

            VOLO = '3',

            FWAF = '4',

            IDAF = '5',

            VOLW = '6',

            FULF = '7',

            FULA = '8',

            FULV = '9',

            FULJ = 'V',

            COAF = 'W',

            NotApplicable = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, DeferralEnrichmentType::Enum);

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

    struct DuplicativeIndicator
    {
        typedef Byte Base;
 
        enum Enum
        {
            DuplicativeTradeReport = '1',

            UniqueTradeReport = '-',
 
        };
    };

    ONIXS_LSE_GTP_API void toStr(std::string&, DuplicativeIndicator::Enum);

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

    struct Side
    {
        typedef Byte Base;
 
        enum Enum
        {
            None = ' ',

            Buy = 'B',

            Sell = 'S',
 
        };
    };

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

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