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/EuroTLX/MarketData/GTP/Defines.h>


namespace OnixS {
namespace EuroTLX {
namespace MarketData {
namespace GTP {


    /// EventCode
    struct EventCode
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            StartOfDay = 'O',

            /// 
            StartOfOpen = 'T',

            /// 
            StartOfPreClose = 'P',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(EventCode::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

        enum Enum
        {
            /// 
            RRG = 1,

            /// 
            ExpressI = 2,

            /// 
            ExpressII = 3,

            /// 
            Clearstream = 4,

            /// 
            Undefinedvalue = 5,

            /// 
            T2S = 6,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(SettlementSystem::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

        enum Enum
        {
            /// 
            NotCleared = 0,

            /// 
            Cleared = 1,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(ClearingType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(UnderlyingType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// InstrumentOptionStyle
    struct InstrumentOptionStyle
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            EuropeanOptionStyle = 'E',

            /// 
            AmericanOptionStyle = 'A',

            /// 
            PeriodicOptionStyle = 'P',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(InstrumentOptionStyle::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// DirtyCleanPrice
    struct DirtyCleanPrice
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            Unspecified = 0,

            /// 
            Secco = 1,

            /// 
            TelQuel = 2,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(DirtyCleanPrice::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// GrossSettlementIndicator
    struct GrossSettlementIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            GrossSettlement = 'Y',

            /// 
            NetNonGrossSettlement1 = 'N',

            /// 
            NetNonGrossSettlement2 = ' ',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(GrossSettlementIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// InverseOrderbook
    struct InverseOrderbook
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            No = 0,

            /// 
            Yes = 1,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(InverseOrderbook::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// SessionChangeReason
    struct SessionChangeReason
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            ScheduledTransition = 0,

            /// 
            ExtendedbyMarketOps = 1,

            /// 
            ShortenedbyMarketOps = 2,

            /// 
            MarketOrderImbalance = 3,

            /// 
            PriceOutsideRange = 4,

            /// 
            AespCircuitBreakerTripped = 5,

            /// 
            SpecialistNotPresent = 6,

            /// 
            Unavailable = 9,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(SessionChangeReason::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// Side
    struct Side
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            BuyOrder = 'B',

            /// 
            SellOrder = 'S',

        };
    };

    /// Appends string presentation of object.
    ONIXS_EUROTLX_GTP_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;
    }

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

        enum Enum
        {
            /// 
            LimitOrderFirmQuote = 0,

            /// 
            MarketOrder = 1,

            /// 
            ImpliedOrder = 2,

            /// 
            NamedLimit = 3,

            /// 
            NamedMarket = 4,

            /// 
            ExecutableQuotes = 5,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(OrderType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

            /// 
            CrossCPITrade = 25,

            /// 
            CPITrade = 26,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TradeType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// TradeQualifier
    struct TradeQualifier
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            TradeAtLast = 'T',

            /// 
            NotApplicable = ' ',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TradeQualifier::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// AuctionType
    struct AuctionType
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            Undefined = 0,

            /// 
            ClosingAuction = 'C',

            /// 
            OpeningAuction = '0',

            /// 
            AESP = 'A',

            /// 
            EDSP = 'B',

            /// 
            OPA = 'P',

            /// 
            ResumeAuction = 'E',

            /// 
            PeriodicAuction = 'F',

            /// 
            IntradayLevel1Auction = 'G',

            /// 
            FrequentLitAuctions = 'L',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(AuctionType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

            /// 
            TradeHighOffBook = 12,

            /// 
            TradeLowOffBook = 13,

            /// 
            OpenInterest = 14,

            /// 
            Volatility = 15,

            /// 
            StaticReferencePrice = 16,

            /// 
            DynamicReferencePrice = 17,

            /// 
            PBBOMidpointPriceWFMCsHavePassed3 = 18,

            /// 
            PBBOMidpointPriceWFMCsHaveFailed3 = 19,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(StatisticType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// AuctionInfo
    struct AuctionInfo
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            Undefined = 0,

            /// 
            BuyImbalance = 'B',

            /// 
            NoImbalance = 'N',

            /// 
            InsufficientOrdersforAuction = 'O',

            /// 
            SellImbalance = 'S',

            /// 
            CallMarket = 'M',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(AuctionInfo::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// AnnouncementType
    struct AnnouncementType
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            Regular = '0',

            /// 
            HighPriority = '1',

            /// 
            LowPriority = '2',

            /// 
            StressedMarketConditionStart = '3',

            /// 
            StressedMarketConditionEnd = '4',

            /// 
            StressedMarketObligationsStart = '5',

            /// 
            StressedMarketObligationsEnd = '6',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(AnnouncementType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

        enum Enum
        {
            /// 
            AllBooks = 0,

            /// 
            FirmQuote = 1,

            /// 
            OffBook = 2,

            /// 
            Electronic = 3,

            /// 
            PrivateRFQ = 4,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(OrderBookType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// SourceVenue
    struct SourceVenue
    {
        /// Integral type used as basement for constants. 
        typedef UInt16 Base;

        enum Enum
        {
            /// 
            LondonStockExchange = 1,

            /// 
            BorsaItalianaAndEuroTlxCashEquitiesAndFixedIncome = 2,

            /// 
            BorsaItalianaDerivatives = 3,

            /// 
            TurquoiseLit = 5,

            /// 
            TurquoisePlato = 6,

            /// 
            BorsaItalianaTradingAfterHours = 8,

            /// 
            TRADEcho = 11,

            /// 
            TurquoisePlatoLitAuctions = 12,

            /// 
            ReservedForFutureUse = 13,

            /// 
            TurquoiseLitOrderBookTGHE = 14,

            /// 
            TurquoisePlatoOrderBookTGHE = 15,

            /// 
            TurquoisePlatoLitAuctionsOrderBookTGHE = 16,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(SourceVenue::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// TradingStatus
    struct TradingStatus
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            None = 0,

            /// 
            Halt = 'H',

            /// 
            HaltMatchingPartitionSuspended = 'J',

            /// 
            HaltSystemSuspended = 'K',

            /// 
            HaltRegulatoryHalt = 'P',

            /// 
            HaltInstrumentLevelCircuitBreakerTripped = 'L',

            /// 
            RegularTradingStartTradeReporting = 'T',

            /// 
            ResumeOrderDeletionPeriod = 'R',

            /// 
            TradingStop = 'S',

            /// 
            PostClose = 'b',

            /// 
            MarketClosed = 'c',

            /// 
            NoActiveSession = 'w',

            /// 
            EndOfPostClose = 'x',

            /// 
            PreTrading = 'y',

            /// 
            ClosingPricePublication = 'z',

            /// 
            QuotingPeriod = 'Q',

            /// 
            InactiveUnderlyingSuspended = '1',

            /// 
            Suspended = '2',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TradingStatus::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// ImbalanceDirection
    struct ImbalanceDirection
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            BuyImbalance = 'B',

            /// 
            NoImbalance = 'N',

            /// 
            InsufficientOrdersForAuction = 'O',

            /// 
            SellImbalance = 'S',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(ImbalanceDirection::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

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

        enum Enum
        {
            /// 
            NotApplicable = 0,

            /// 
            Visible = 1,

            /// 
            Hidden = 2,

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(HiddenExecutionIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// TradeSummarySide
    struct TradeSummarySide
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            NoSide = ' ',

            /// 
            Buy = 'B',

            /// 
            Sell = 'S',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TradeSummarySide::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// MarketMechanism
    struct MarketMechanism
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            QuoteDrivenMarket = '2',

            /// 
            DarkOrderBook = '3',

            /// 
            OffBook = '4',

            /// 
            PeriodicAuction = '5',

            /// 
            RequestforQuotes = '6',

            /// 
            AnyOther = '7',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(MarketMechanism::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// TradingMode
    struct TradingMode
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            ScheduledOpeningAuction = 'O',

            /// 
            ScheduledClosingAuction = 'K',

            /// 
            ScheduledIntradayAuction = 'I',

            /// 
            UnscheduledAuction = 'U',

            /// 
            ContinuousTrading = '2',

            /// 
            AtMarketCloseTrading = '3',

            /// 
            OutOfMainSessionTrading = '4',

            /// 
            TradeReportingOnExchange = '5',

            /// 
            TradeReportingOffExchange = '6',

            /// 
            TradeReportingSystematicInternaliser = '7',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TradingMode::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// TransactionCategory
    struct TransactionCategory
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            DarkTrade = 'D',

            /// 
            TradeThatHasReceivedPriceImprovement = 'R',

            /// 
            PackageTrade = 'Z',

            /// 
            ExchangeForPhysicalsTrade = 'Y',

            /// 
            NoneApply = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(TransactionCategory::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// NegotiationIndicator
    struct NegotiationIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            NegotiatedTrade = 'N',

            /// 
            NegotiatedTradeInLiquidFinancialInstruments = '1',

            /// 
            NegotiatedTradeInIlliquidFinancialInstruments = '2',

            /// 
            NegotiatedTradeSubjectToConditionsOtherMarketPrice = '3',

            /// 
            NotANegotiatedTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(NegotiationIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// AgencyCrossIndicator
    struct AgencyCrossIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            AgencyCrossTrade = 'X',

            /// 
            NoAgencyCrossTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(AgencyCrossIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// ModificationIndicator
    struct ModificationIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            TradeAmendment = 'A',

            /// 
            NewTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(ModificationIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// ReferencePriceIndicator
    struct ReferencePriceIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            BenchmarkTrade = 'B',

            /// 
            ReferencePriceTrade = 'S',

            /// 
            NotAReferencePriceTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(ReferencePriceIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// SpecialDividendIndicator
    struct SpecialDividendIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            SpecialDividendTrade = 'E',

            /// 
            NoSpecialDividendTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(SpecialDividendIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// OffBookAutomatedIndicator
    struct OffBookAutomatedIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            OffBookNonAutomated = 'M',

            /// 
            OffBookAutomated = 'Q',

            /// 
            Unspecified = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(OffBookAutomatedIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// PriceFormationIndicator
    struct PriceFormationIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            PlainVanillaTrade = 'P',

            /// 
            NonPriceFormingTrade = 'T',

            /// 
            TradeNotContributingToPriceDiscovery = 'J',

            /// 
            PendingPrice = 'N',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(PriceFormationIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// AlgorithmicIndicator
    struct AlgorithmicIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            AlgorithmicTrade = 'H',

            /// 
            NotAlgorithmicTrade = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(AlgorithmicIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// PostTradeDeferralReason
    struct PostTradeDeferralReason
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

        enum Enum
        {
            /// 
            DeferralForLargeInScale = '2',

            /// 
            DeferralForIlliquidInstrument = '3',

            /// 
            DeferralForSizeSpecific = '4',

            /// 
            DeferralsOfIlqdAndSize = '5',

            /// 
            DeferralsOfIlqdAndLrgs = '6',

            /// 
            ImmediatePublication = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(PostTradeDeferralReason::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// DeferralEnrichmentType
    struct DeferralEnrichmentType
    {
        /// Integral type used as basement for constants. 
        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 = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(DeferralEnrichmentType::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

    /// DuplicativeIndicator
    struct DuplicativeIndicator
    {
        /// Integral type used as basement for constants. 
        typedef Byte Base;

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

            /// 
            UniqueTradeReport = '-',

        };
    };

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

    /// Returns string presentation of object.
    inline std::string toStr(DuplicativeIndicator::Enum value)
    {
        std::string str;
        toStr(str, value);
        return str;
    }

}
}
}
}