tt_cplus_sdk.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
 
 
#ifndef DEPRECATE_SUPER_STRING
    #define DEPRECATE_SUPER_STRING
#endif
#ifndef SUPER_STRING_IS_STD_STRING
    #define SUPER_STRING_IS_STD_STRING
#endif 
 
 
#include <sys/types.h>
#include "consts.h"
#include "sdk_options.h"
#include "account.h"
#include "customer_profile.h"
#include "instrument.h"
#include "algo_definition.h"
#include "instrument_search.h"
#include "prices.h"
#include "order.h"
#include "fill.h"
#include "position.h"
#include "connection.h"
#include "enums/MarketId.h"
#include "sdkalgo.h"
 
 
namespace ttsdk {
 
 
    class IEventHandler
    {
    public:
        enum class Status
        {
            INITIALIZED,      // SDK has been initialized but it not fully ready (some aspects of the SDK might still be negotiating)
            READY,            // SDK is fully functional
            UNAUTHORIZED,     // SDK is no longer permissioned
            RECOMMEND_UPDATE, // SDK should be upgraded
            REQUIRES_UPDATE,  // SDK must be upgraded
            FORCED_SHUTDOWN,  // SDK is being forced to shutdown due to error
            SDKALGO_CONNECTED,  // SDK Algo support is connected and ready
            EDGE_NOT_CONNECTED,  // SDK could not connect to the edge for synthetic and position data
            SDKALGO_NOT_CONNECTED,  // SDK could not connect to the edge for SDK Algo support
            DOWN,                   // SDK is down
            INVALID_PRICE_CONFIG,     // Invalid Price Config file was downloaded
            ORDER_THROTTLE_LIMIT_EXCEEDED,  // Number of orders sent in 1 second exceeded the limit
            EDGE_DISCONNECTED,      // SDK lost connectivity to the edge - it will reconnect
        };
 
        IEventHandler() {};
        virtual ~IEventHandler() {};
        virtual void OnStatus(const Status status) = 0;
        virtual void OnAccountStatus(const AccountConnectionStatus& connectionStatus) {};
        virtual void OnInstrumentUpdated(InstrumentPtr /*oldInstrument*/, InstrumentPtr /*newInstrument*/) {};
        virtual void OnInstrumentDeleted(InstrumentPtr /*deletedInstrument*/) {};
        virtual void OnAlgoDefinitionUpdated(AlgoDefinitionPtr /*oldAlgo*/, AlgoDefinitionPtr /*newAlgo*/) {};
        virtual void OnAlgoDefinitionDeleted(AlgoDefinitionPtr /*deletedAlgo*/) {};
    };
    using IEventHandlerPtr = IEventHandler*;
 
 
    bool Initialize(const TTSDKOptions& options, IEventHandlerPtr sdkEventObserver, 
                    IOrderBookEventHandlerPtr orderHandler, ISDKAlgoManagerPtr algoManager = nullptr) noexcept;
 
    void Shutdown() noexcept;
 
    const char* Version() noexcept;
 
    //----------------------------------------------------------------------------
 
    typedef enum
    {
        LogDebug = 0,
        LogInfo = 10,
        LogWarning = 20,
        LogError = 30,
        LogCritical = 40,
        LogAlways = 100      //  this level is used for messages which must be logged regardless of the minimal logging level
    } LogLevel;
 
#ifdef _WINDOWS
    //           in the TT log file as an INFO level message.
    void TTLogInfo(const char *format, ...);
    //           in the TT log file as an WARNING level message.
    void TTLogWarning(const char *format, ...);
    //           in the TT log file as an ERROR level message.
    void TTLogError(const char *format, ...);
    //           in the TT log file as the specified level message.
    void TTLog(const LogLevel level, const char* category, const char* msg);
#else
    void TTLogInfo(const char *format, ...) __attribute__((format(printf, 1, 2)));
    void TTLogWarning(const char *format, ...) __attribute__((format(printf, 1, 2)));
    void TTLogError(const char *format, ...) __attribute__((format(printf, 1, 2))); 
    void TTLog(const LogLevel level, const char* category, const char *msg) ;
#endif
    //-----------------------------------------------------------------------------------
 
    AccountCollectionPtr GetAccounts();
 
    CustomerProfileCollectionPtr GetCustomerProfiles();
 
    InstrumentPtr GetInstrument(const uint64_t instrumentId, Instrument::ResponseCode& code);
 
    InstrumentPtr GetInstrument(const MarketId market, const char* product, const ProductType type, const char* alias, Instrument::ResponseCode& code);
 
    InstrumentSearchResultsPtr SearchInstruments(const char* query, const char* markets, Instrument::ResponseCode& code);
 
    AlgoDefinitionPtr GetAlgoDefinition(const char* algoName, AlgoDefinition::ResponseCode& code);
 
    OrderPtr CreateOrderFromPriceSub(uint64_t priceSubscriptionId);
    OrderPtr CreateOrder(InstrumentPtr instrument);
    OrderPtr CreateOrder(uint64_t instrumentId);
 
    OrderPtr CreateAlgoOrder(AlgoDefinitionPtr algo, InstrumentPtr instrument);
    OrderPtr CreateAlgoOrder(AlgoDefinitionPtr algo, uint64_t instrumentId = 0);
 
    
    bool DownloadFills(IFillDownloadCallbackHandlerPtr obj,
                       const uint64_t accountId = 0,
                       const ttsdk::MarketId marketId = ttsdk::MarketId::INVALID,
                       const uint64_t minTimestamp = 0,
                       const uint64_t maxTimestamp = 0,
                       const char* orderId = nullptr);
 
 
    uint64_t SubscribePrices(InstrumentPtr instrument, const uint16_t depth,
                             const bool implieds, const bool allowTTImplieds,
                             const bool includeSimPrices,
                             IPriceEventHandlerPtr listener) noexcept;
    uint64_t SubscribePrices(uint64_t instrumentId, const uint16_t depth,
                             const bool implieds, const bool allowTTImplieds,
                             const bool includeSimPrices,
                             IPriceEventHandlerPtr listener) noexcept;
    void UnsubscribePrices(const uint64_t subscriptionId) noexcept;
 
    uint64_t SubscribeTimeAndSales(InstrumentPtr instrument, const bool includeSimPrices,
                                   ITimeSalesEventHandlerPtr listener) noexcept;
    uint64_t SubscribeTimeAndSales(uint64_t instrumentId, const bool includeSimPrices,
                                    ITimeSalesEventHandlerPtr listener) noexcept;
    void UnsubscribeTimeAndSales(const uint64_t subscriptionId) noexcept;
 
    void StartAccount(const uint64_t accountId);
 
 
    // Position Reserve Order support 
    bool ReserveRisk(InstrumentPtr instrument, const uint64_t accountId, const RiskSide side, 
                     const double quantity, const double maxClipSize) noexcept;
    bool ReleaseRisk(InstrumentPtr instrument, const uint64_t accountId, const RiskSide side) noexcept;
    PositionReserveBucket GetRiskBucket(InstrumentPtr instrument, const uint64_t accountId) noexcept;
 
    const char* const GetExchAssocId() noexcept;
 
}