prices.h

Go to the documentation of this file.

/***************************************************************************
 *
 *                  Unpublished Work Copyright (c) 2018-2020
 *                  Trading Technologies International, Inc.
 *                       All Rights Reserved Worldwide
 *
 *          * * *   S T R I C T L Y   P R O P R I E T A R Y   * * *
 *
 * WARNING:  This program (or document) is unpublished, proprietary property
 * of Trading Technologies International, Inc. and is to be maintained in
 * strict confidence. Unauthorized reproduction, distribution or disclosure
 * of this program (or document), or any program (or document) derived from
 * it is prohibited by State and Federal law, and by local law outside of
 * the U.S.
 *
 ***************************************************************************/
#pragma once
 
#include <stddef.h>
#include "enums/ImpliedsSource.h"
#include "enums/TradingStatus.h"
#include "enums/TradeIndicator.h"
#include "enums/ExchSupportedOTCTypes.h"
#include "enums/TradeType.h"
#include "enums/TradeQualifier.h"
#include "instrument.h"
#include "consts.h"
#include <math.h>
 
namespace ttsdk {
 
    enum class PriceEventType
    {
        DIRECT,
        CALCULATED_IMPLIEDS,
        SIMULATED,
        UNKNOWN,
    };
    struct PriceSnap
    {
        static constexpr size_t MAX_DEPTH_LEVEL = 10; 
 
        enum class SnapStatus
        {
            NOT_REQUESTED,
            RECEIVED,
            NOT_RECEIVED,
            ERROR,
            UNKNOWN,
        };
        bool all_snaps_ready;                       
        SnapStatus direct = SnapStatus::UNKNOWN;    
        SnapStatus implied = SnapStatus::UNKNOWN;   
        SnapStatus simulated = SnapStatus::UNKNOWN; 
        ImpliedsSource implieds_source = ImpliedsSource::Noimplieds;
 
        struct DepthSnap
        {
            struct DepthLevel
            {
                double price;            
                int32_t order_count;     
                double quantity;         
                double implied_quantity; 
            } levels[MAX_DEPTH_LEVEL];
 
            size_t count; 
        };
 
        uint64_t instrument_id; 
        TradingStatus market_state; 
 
        DepthSnap asks; 
        DepthSnap bids; 
 
        double open_price = NAN;          
        double close_price = NAN;         
        double high_price = NAN;          
        double low_price = NAN;           
        double last_trade_price = NAN;    
        double last_trade_quantity = NAN; 
        double volume = NAN;              
        double cum_last_trade_quantity = NAN; 
        double settlement_price = NAN;    
        uint64_t settlement_time = U64NAN;  
        double open_interest = NAN;       
        uint64_t epoch_transact_time_nano = 0;
 
        double ind_settle = NAN;          
        double ind_price = NAN;           
        double ind_quantity = NAN;        
        double ind_bid = NAN;             
        double ind_ask = NAN;             
 
 
        PriceEventType event_type;  
        uint64_t seq_no;            
        uint64_t conflation_no;     
        uint64_t exchange_time;     
        uint64_t server_time;       
        uint64_t client_time;       
        uint64_t sdk_time;          
        uint64_t exchange_seq_no;
    };
 
    struct TimeSales
    {
        static constexpr size_t MAX_EVENTS = 10; 
        uint64_t instrument_id;                  
        PriceEventType event_type;
        size_t count;                            
 
        struct Trade
        {
            double last_trade_price = NAN;           
            double last_trade_quantity = NAN;        
            ttsdk::TradeType trade_side;             
            ttsdk::TradeQualifier qualifier;         
            ttsdk::TradeIndicator  indicator;
            ttsdk::ExchSupportedOTCTypes otc_type;
            uint32_t bid_counterparty_id;
            uint32_t ask_counterparty_id;
 
            double   alternate_last_traded_price = NAN;
            double   alternate_last_traded_quantity = NAN;
            uint64_t alternate_epoch_transact_time_nano = 0;
 
            uint64_t epoch_transact_time_nano;       
            uint64_t exchange_transact_time_ns;
            uint64_t exchange_seq_no;
        };
        Trade trades[MAX_EVENTS];
 
    };
 
 
    enum class SubscriptionError {
        UNKNOWN_CLIENT,
        DUPLICATE_SUBSCRIPTION,
        INVALID_INSTRUMENT,
        INVALID_INSTRUMENT_SYMBOL,
        PARTYID_NOT_SUPPORTED,
        INSTRUMENT_ID_MISMATCH,
        INACTIVE_INSTRUMENT,
        DUPLICATE_SUBSCRIPTION_ID,
        UNKNOWN_SUBSCRIPTION_ID,
        INVALID_SUBSCRIPTION_PARAMETERS,
        NOT_PERMISSIONED,
        NOT_INITIALIZED,
        INVALID_CONFIGURATION,
        NOTTRADABLE_INSTRUMENT,
        NO_CONNECTIVITY,
        EXCEEDED_MAX_SUBS_ALLOWED,        
        NOT_SUPPORTED,
        PRODUCT_INFO_NOT_AVAILABLE,        
        UNKNOWN,
        NONE
    };
 
    class IPriceEventHandler
    {
    public:
        virtual ~IPriceEventHandler(void) noexcept = default;
 
        virtual void OnPriceUpdate(const uint64_t subId, const InstrumentPtr& instrument, const PriceSnap& snap) = 0;
 
        virtual void OnError(const uint64_t subId, const InstrumentPtr& instrument,
                             const SubscriptionError code, const char* error) = 0;
 
        virtual void OnDisconnect(const uint64_t subId, const InstrumentPtr& instrument, const PriceEventType type) = 0;
 
        //         destroy the handler object (sdk will no longer use it)
        virtual void OnUnsubscribed(const uint64_t subId) = 0;
    };
    using IPriceEventHandlerPtr = IPriceEventHandler*;
 
    class ITimeSalesEventHandler
    {
    public:
        virtual ~ITimeSalesEventHandler(void) noexcept = default;
 
        virtual void OnTimeSalesUpdate(const uint64_t subId, const InstrumentPtr& instrument, const TimeSales& ts) = 0;
 
        virtual void OnError(const uint64_t subId, const InstrumentPtr& instrument,
                             const SubscriptionError code, const char* error) = 0;
 
        virtual void OnDisconnect(const uint64_t subId, const InstrumentPtr& instrument, const PriceEventType type) = 0;
 
        //         destroy the handler object (sdk will no longer use it)
        virtual void OnUnsubscribed(const uint64_t subId) = 0;
    };
    using ITimeSalesEventHandlerPtr = ITimeSalesEventHandler*;
 
 
 
}