FuturesProductDefinition.h

Go to the documentation of this file.

/**
 * \file
 * \brief Declare `OnixS::ICE::iMpact::MarketData::FuturesProductDefinition` message structure
 */
/*
 * Copyright (c) Onix Solutions Limited. All rights reserved.
 *
 * This software owned by Onix Solutions Limited 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 "../Export.h"
#include "../Types.h"
#include "../Enumerations.h"
#include "../Time.h"
#include "../Optional.h"

#include <iosfwd>
#include <string>
#include <vector>

namespace OnixS { namespace ICE { namespace iMpact { namespace MarketData {

/// This class represents the Futures/OTC Product Definition Response Message.
struct ONIXS_ICEMDH_EXPORT FuturesProductDefinition
{
    /// Message type constant
    enum  { messageType = 'B' };

    /// The original request sequence ID assigned by client, unique per
    /// session.
    int requestSeqId;

    /// See Appendix C for the list of market types and IDs.
    MarketType requestMarketType;

    /// Unique identifier of the market.
    MarketId marketId;

    /// See Naming Convention on Appendix D.
    std::string contractSymbol;

    /// See Appendix A on trading status codes.
    TradingStatus::Enum tradingStatus;

    /// Denominator for the order price fields in this market.
    char orderPriceDenominator;

    /// Minimum increment price for this market.
    int incrementPrice;

    /// Minimum increment quantity for this market.
    int incrementQty;

    /// The lot size is minimum size of contracts in lots. It is multiplier to
    /// determine the total lots.
    int lotSize;

    /// Description of the market.
    std::string marketDesc;

    /// 4 digit year. Last date that the market can be traded and should be
    /// removed from the system.
    short maturityYear;

    /// Month range 1-12. Last date that the market can be traded and should
    /// be removed from the system.
    short maturityMonth;

    /// Day of the month. Last date that the market can be traded and should
    /// be removed from the system.
    short maturityDay;

    /// Indicate if the market is a spread.
    bool isSpread;

    /// Indicate if the market is crack spread.
    bool isCrackSpread;

    /// Ignored when it is not spread.
    MarketId primaryMarketId;

    /// Ignored when it is not spread.
    MarketId secondaryMarketId;

    /// Denominator for the deal price fields in the market. For most markets,
    /// this is the same as OrderPriceDenominator. However, it could be
    /// different for some crack or spread markets.
    char dealPriceDenominator;

    /// Minimum quantity for this market.
    int minQty;

    /// The quantity in unit of measurement per lot. For example, it is 1000
    /// barrels per lot for Brent.
    int unitQuantity;

    /// The currency that the market is traded on.
    std::string currency;

    /// Only used for `OffExchangeIncrementOptionPrice`.
    char numDecimalsOptionsPrice;

    /// Use `ScreentickValue` and `BlockTickValue` instead of this field.
    /// `OrderPriceDenominator` should be applied to get the real value.
    /// Please take note that this value can be different for the same markets
    /// with different expiry and that this value can change over time for a
    /// given market (i.e. `MarketID`).
    long long oldTickValue;

    /// Indicate if the market supports option markets.
    bool allowOptions;

    /// Clearing limit admin related.
    std::string clearedAlias;

    /// Indicate if implication is done for a given spread market and its
    /// given outright leg markets.
    bool allowsImplied;

    /// 4 digit year.
    short optionsExpirationYear;

    /// Month range 1-12.
    short optionsExpirationMonth;

    /// Day of the month.
    short optionsExpirationDay;

    /// Minimum Price.
    Price minPrice;

    /// Maximum Price.
    Price maxPrice;

    /// Name of the product that the contract/market is under.
    std::string productName;

    /// Alias of the hub for the contract/market.
    std::string hubAlias;

    /// Name of the strip for the contract/market.
    std::string stripName;

    /// Indicate if serial options is supported.
    bool isSerialOptionsSupported;

    /// Indicate if the contract is tradable.
    bool isTradable;

    /// Denominator for the settlement price fields in the market. For most
    /// markets, this is the same as DealPriceDenominator.
    char settlePriceDenominator;

    /// Market Identifier Code for the market.
    std::string micCode;

    /// Denominator for UnitQuantity. Clients should also apply
    /// UnitQtyDenominator when calculating LotSize. This field will be `0`
    /// for most of the markets.
    char unitQtyDenominator;

    /// Contains the Strategy Code for defined market where applicable. See
    /// Appendix E for list of codes.
    SecuritySubType::Enum securitySubType;

    /// Indicate if the contract is for hedge only.
    bool hedgeOnly;

    /// Exchange silo code for the market.
    ExchangeSilo::Enum exchangeSilo;

    /// Denominator for `OffExchangeIncrementQty`.
    char offExchangeIncrementQtyDenominator;

    /// Off exchange increment qty. `OffExchangeIncrementQtyDenominator`
    /// should be applied to this field.
    int offExchangeIncrementQty;

    /// Off exchange increment price. `OrderPriceDenominator` should be
    /// applied to this field.
    int offExchangeIncrementPrice;

    /// Off exchange options increment price. `NumDecimalsOptionsPrice` should
    /// be applied to this field.
    int offExchangeIncrementOptionPrice;

    /// ID of the product that the contract/market is under.
    int productId;

    /// ID of the hub for the contract/market.
    int hubId;

    /// ID of the strip for the contract/market.
    int stripId;

    /// The ISIN of the security this market is associated with. This is
    /// currently only populated for Liffe Equity markets.
    std::string underlyingISIN;

    /// This nested class represents block details definition.
    struct ONIXS_ICEMDH_EXPORT BlockDetail
    {
        /// Block Type.
        BlockType::Enum blockType;

        /// Trade Type.
        OffMarketTradeType::Enum tradeType;

        /// Minimum Quantity. `OffExchangeIncrementQtyDenominator` should be
        /// applied to this field.
        long long minQty;

        /// Default constructor.
        BlockDetail();

        /// Returns string representation.
        std::string toString() const;
    };

    /// Alias for collection of BlockDetails.
    typedef std::vector<BlockDetail> BlockDetails;

    /// Collection of BlockDetails.
    Optional<BlockDetails> blockDetails;

    /// Denominator for the alternate deal price fields in the market.
    Optional<char> altPriceDenominator;

    /// Fixed Rate: The fixed rate for an instrument.
    Optional<long long> couponRate;

    /// Fixed Rate: The fixed rate Denominator for an instrument.
    Optional<char> couponRateDenominator;

    /// Cash Flow Alignment Date: The cash flow alignment date is a date not
    /// adjusted for holidays used to derive interest payment dates. Any
    /// calendar day.
    Optional<DateTime> datedDate;

    /// Effective Date: The effective date of the swap future. Any business
    /// day.
    Optional<DateTime> interestAccrualDate;

    /// First Fixing Date: The first Fixing Date is the date at which the
    /// float rate is set during the first float period. Any acceptable
    /// business day.
    Optional<DateTime> issueDate;

    /// Previous Fixing Rate: The rate set on the last reset date. Sent for
    /// float leg on aged or spot starting swap futures. Not sent for forward
    /// starting swap futures. Number of decimal places for RepurchaseRate is
    /// 5. `0` is valid for this field up until the First Fixing Date
    /// (IssueDate).
    Optional<Price> repurchaseRate;

    /// Previous Fixing Date: The date the floating rate was set for the next
    /// floating payment. Milliseconds since Jan 1st, 1970, 00:00:00 GMT. `0`
    /// is valid for this field up until the First Fixing Date (IssueDate).
    Optional<DateTime> repurchaseDate;

    /// Index Factor: Percentage of the original index that is still accruing
    /// interest. Number of decimal places for Factor is 2.
    Optional<long long> factor;

    /// Interpolation Factor: Multiplier that when applied to the longer rate
    /// in the CreditRating (Rate Descriptor) field results in RepurchaseRate
    /// (Previous Fixing Rate). Not sent for forward starting interest rate
    /// swap futures.
    Optional<long long> interpolationFactor;

    /// Denominator value for ContractMultiplier.
    Optional<char> interpolationFactorDenominator;

    /// Payment Frequency: The interest rate swap future payment frequency.
    /// Supported values: `6M` = 6 months, `1Y` = 1 year.
    Optional<std::string> instrRegistry;

    /// Rate Descriptor: The description of Float Rate. Sent for float leg on
    /// aged or spot starting swap futures.
    Optional<std::string> creditRating;

    /// Total Premium Accrual: Premium that has accrued during the current
    /// quarterly payment period. Based on 100 Notional and will be applied to
    /// the `A` value. Number of decimal places for AccruedPremiumAmt is 10.
    Optional<long long> accruedPremiumAmt;

    /// CDS - Premium & Credit Event Payments (B): This value represents
    /// historical premium and credit event payments for 100 notional, and is
    /// one of the primary inputs needed for calculating a futures price for a
    /// swap future. IRS - Accrued Coupons (B Value): This value represents
    /// historical fixed and floating payments for 100 notional, and is one of
    /// the primary inputs needed for calculating a futures price for an
    /// interest rate swap future. Number of decimal places for
    /// EventPaymentAmt is 10. This value can be negative.
    Optional<long long> eventPaymentAmt;

    /// Price Alignment Interest (C): Eris PAI is the cumulative daily
    /// interest on variation margin adjustment for 100 notional. Eris PAI is
    /// one of the primary inputs needed for calculating a futures price for a
    /// swap future. IRS - Accrued Coupons (B Value): This value represents
    /// historical fixed and floating payments for 100 notional, and is one of
    /// the primary inputs needed for calculating a futures price for a swap
    /// future. Denominator value for AlignmentInterestRate is 10.
    Optional<long long> alignmentInterestRate;

    /// Settlement Type.
    Optional<SettlementType::Enum> settlementType;

    /// Indicates if Market is only tradable via ICE Block Trade. This also
    /// means the screen trading is not allowed for the market.
    Optional<bool> isBlockOnly;

    /// Indicates if flexible strikes can be created for the option market.
    Optional<bool> flexAllowed;

    /// Market ID for the corresponding hedge market. It will be set to `-1`
    /// when not applicable.
    Optional<MarketId> hedgeMarketId;

    /// The number of markets for the given market type.
    Optional<int> numOfMarkets;

    /// Only sent if contract symbol is greater than 35. Client should use
    /// this field if sent else use existing contract symbol field.
    Optional<std::string> contractSymbolExtra;

    /// Unit Of Measure.
    Optional<std::string> unitOfMeasure;

    /// Indicates if GTC is allowed in the market.
    Optional<bool> gtAllowed;

    /// Indicates if Cross order is supported in the market.
    Optional<bool> crossOrderSupported;

    /// Indicates if AON order is supported in the market.
    Optional<bool> aonAllowed;

    /// Indicates MIFID-II market.
    Optional<bool> miFIDRegulatedMarket;

    /// Indicates this is a test market.
    Optional<bool> testMarketIndicator;

    /// Product ID to use when requesting new spread.
    Optional<int> refSpreadProductId;

    /// This ISIN is only supported for MiFID Regulated Markets. Of the MiFID
    /// markets, only Futures and Options markets will support ISINs; some
    /// strategies will have an ISIN.
    Optional<std::string> isin;

    /// This field can be used to identify if a market is Platts or not.
    Optional<MarketTransparencyType::Enum> marketTransparencyType;

    /// ScreenLastTradeDate is the last date, by Exchange rule, that the
    /// market is available for trading on the Central Order Book. It applies
    /// to all cleared instruments on the trading platform.
    Optional<Date> screenLastTradeDate;

    /// Indicates if dividend is adjusted.
    Optional<bool> isDividendAdjusted;

    /// Indicates whether the Block Minimum can be overridden for the market.
    Optional<bool> overrideBlockMin;

    /// The deliverable quantity of a stock, commodity, or other financial
    /// instrument that underlies a futures or options contract.
    Optional<int> contractSize;

    /// Identifies the monetary amount per tick move when calculated from the
    /// Central Limit Order Book.
    Optional<long long> screenTickValue;

    /// Identifies the monetary amount per tick move when calculated for Off-
    /// Exchange trades.
    Optional<long long> blockTickValue;

    /// Denominator for ScreenTickValue and BlockTickValue.
    Optional<char> tickValueDenominator;

    /// Denominator for ContractSize.
    Optional<char> contractSizeDenominator;

    /// Number of cycles (days, hours, MWh, etc) for a contract.
    Optional<int> numOfCycles;

    /// Indicates when a market is standard vs nonstandard. Field will only
    /// exist on/be applicable to equity markets. Default value is false.
    Optional<bool> isStandardEquity;

    /// Default constructor.
    FuturesProductDefinition();

    /// Initialize from raw message data.
    FuturesProductDefinition(const char* data, size_t dataSize);

    /// Deserialize from raw data.
    void deserialize(const char* data, size_t dataSize);

    /// Reset all fields to default values.
    void reset();

    /// Returns string representation.
    std::string toString() const;
};

/// Make it printable using C++ I/O streams.
ONIXS_ICEMDH_EXPORT std::ostream& operator<<(std::ostream&, const FuturesProductDefinition&);

}}}}                                                        // namespace MarketData, iMpact, ICE, OnixS