NewOptionsStrategyDefinition.h

Go to the documentation of this file.

/**
 * \file
 * \brief Declare `OnixS::ICE::iMpact::MarketData::NewOptionsStrategyDefinition` 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 New Options Strategy Definition Message.
struct ONIXS_ICEMDH_EXPORT NewOptionsStrategyDefinition
{
    /// Message type constant
    enum  { messageType = 'U' };

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

    /// Unique identifier of the underlying 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 premium price for this market.
    int incrementPrice;

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

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

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

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

    /// Strategy Symbol.
    std::string strategySymbol;

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

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

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

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

    /// Indicates Test Market.
    bool testMarketIndicator;

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

    /// Indicates whether leg deals are suppressed.
    bool legDealSuppressed;

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

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

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

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

    /// See Appendix C for the list of makret types and IDs.
    short marketTypeId;

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

    /// Number of cycle (days, hours, MWh, etc.) for a contract.
    int numOfCycles;

    /// Minimum price. `OrderPriceDenominator` should be applied to this
    /// field.
    Price minPrice;

    /// Maximum price. `OrderPriceDenominator` should be applied to this
    /// field.
    Price maxPrice;

    /// This nested class represents leg definition.
    struct ONIXS_ICEMDH_EXPORT Leg
    {
        /// Market Id of the option leg market.
        MarketId marketId;

        /// Futures market id of the underlying futures market.
        MarketId underlyingMarketId;

        /// Number of option contracts per increment quantity.
        short ratio;

        /// Leg side.
        Side::Enum side;

        /// The strategy code for the leg. If set, this field can be used to
        /// obtain the next level of granularity of the strategy. If it is not
        /// set, the /c LegMarketID is the most granular level for the market. See
        /// Appendix E for list of codes.
        Optional<short> strategyCode;

        /// The quantity ratio represents the proportion of each of the leg of
        /// interproduct spreads. Using Gas Oil crack as an example. This will be
        /// set to 4 for the Gas oil leg and 3 for the Brent leg.
        Optional<int> ratioQtyNumerator;

        /// The quantity ratio represents the proportion of each of the leg of
        /// interproduct spreads. The Leg ratio denominator will be set to `1` for
        /// most products not but will be used in future product launches.
        Optional<int> ratioQtyDenominator;

        /// The price ratio is the fractional weighted price component per leg in
        /// the strategy. Using a Q4 2017 set as composite strategy as an example,
        /// each leg Oct 2017, Nov 2017 and Dec 2017 will have 1 as the
        /// `LegRatioPriceNumerator`.
        Optional<int> ratioPriceNumerator;

        /// The price ratio is the fractional weighted price component per leg in
        /// the strategy. Using a Q4 2017 set as composite strategy as an example,
        /// each leg Oct 2017, Nov 2017 and Dec 2017 will have 3 as the
        /// `LegRatioPriceDenominator`.
        Optional<int> ratioPriceDenominator;

        /// Default constructor.
        Leg();

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

    /// Alias for collection of Legs.
    typedef std::vector<Leg> Legs;

    /// Collection of Legs.
    Legs legs;

    /// This nested class represents hedge definition.
    struct ONIXS_ICEMDH_EXPORT Hedge
    {
        /// Future's market id of the hedge.
        MarketId marketId;

        /// Security type.
        SecurityType::Enum securityType;

        /// Hedge side.
        Side::Enum side;

        /// Hedge price.
        Price price;

        /// Hedge price denominator.
        char priceDenominator;

        /// The strategy code for the leg. If set, this field can be used to
        /// obtain the next level of granularity of the strategy. If it is not
        /// set, the /c LegMarketID is the most granular level for the market. See
        /// Appendix E for list of codes.
        short strategyCode;

        /// Hedge delta.
        int delta;

        /// Default constructor.
        Hedge();

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

    /// Alias for collection of Hedges.
    typedef std::vector<Hedge> Hedges;

    /// Collection of Hedges.
    Hedges hedges;

    /// Default constructor.
    NewOptionsStrategyDefinition();

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

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