OptionsProductDefinition.h

Go to the documentation of this file.

/**
 * \file
 * \brief Declare `OnixS::ICE::iMpact::MarketData::OptionsProductDefinition` 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 "../Optional.h"

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

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

/// This class represents the Options Product Definition Message.
struct ONIXS_ICEMDH_EXPORT OptionsProductDefinition
{
    /// Message type constant
    enum  { messageType = 'p' };

    /// 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 option market.
    MarketId marketId;

    /// Underlying Futures/OTC market id. This market id links to the product
    /// definition of the futures market.
    MarketId underlyingMarketId;

    /// 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 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;

    /// Option type.
    OptionType::Enum optionType;

    /// Strike Price of the option. Used in conjunction with the
    /// NumDecimalsStrikePrice. This is often different from the premium price
    /// decimals.
    Price strikePrice;

    /// Denominator for the deal price fields in the market. For most markets,
    /// this is the same as OrderPriceDenominator.
    char dealPriceDenominator;

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

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

    /// Denominator for the strike price field.
    char numDecimalsStrikePrice;

    /// Minimum premium price for the option.
    Price minOptionsPrice;

    /// Maximum premium price for the option.
    Price maxOptionsPrice;

    /// Price increment for the option market.
    int incrementPremiumPrice;

    /// 4 digit year.
    short optionsExpirationYear;

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

    /// Day of the month.
    short optionsExpirationDay;

    /// Options style.
    OptionsStyle::Enum optionsStyle;

    /// Options expiration type.
    OptionsExpirationType::Enum optionsExpirationType;

    /// The number of options markets for the given market type.
    int numOfMarkets;

    /// The underlying futures market ID for a serial option. The serial
    /// option market may or may not be a valid futures month and option will
    /// expire/exercise into a position held in this underlying market. It
    /// will be set to `-1` when not applicable.
    MarketId hedgeMarketId;

    /// Extra contract symbol. Some contract symbols might contain more than
    /// 35 characters. Clients should append this field to ContractSymbol
    /// (Offset 19) to get the complete contract symbol.
    std::string contractSymbolExtra;

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

    /// Denominator for UnitQuantity. This field will be `0` for most of the
    /// markets.
    char unitQtyDenominator;

    /// Use `ScreentickValue` and BlockTickValue instead of this field.
    /// `OrderPriceDenominator` should be applied to get the real value.
    long long oldTickValue;

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

    /// Settlement type.
    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.
    bool isBlockOnly;

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

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

    /// Indicates if Guarantee Cross is supported in the market.
    bool guaranteedCrossSupported;

    /// Unit Of Measure.
    std::string unitOfMeasure;

    /// Indicates MIFID-II market.
    bool miFIDRegulatedMarket;

    /// Indicates Test Market.
    bool testMarketIndicator;

    /// 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.
    std::string isin;

    /// Screen last trade year, 4 digits.
    short screenLastTradeYear;

    /// Screen last trade month, range 1-12.
    short screenLastTradeMonth;

    /// Screen last trade day of the month.
    short screenLastTradeDay;

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

    /// 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.
    BlockDetails blockDetails;

    /// 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;

    /// The product id for the market. For options, the ProductID will be that
    /// of the underlying product.
    Optional<int> productId;

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

    /// Default constructor.
    OptionsProductDefinition();

    /// Initialize from raw message data.
    OptionsProductDefinition(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 OptionsProductDefinition&);

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