orders.hpp

Go to the documentation of this file.

#pragma once

#include <tt_core_sdk/tt_core_sdk.hpp>
#include <tt_core_sdk/enums.hpp>

#include <string>
#include <cstdint>
#include <utility>
#include <functional>
#include <memory>
#include <vector>
#include <limits>

namespace tt_core_sdk {

class OrderHandle;
class OrderManager;
class ExecutionReportImpl;
class OrderCancelRejectImpl;
class OrderHandleImpl;
class OrderManagerImpl;
class SharedOrderManagerImpl;
class Instrument;

struct order_profile
{
    std::shared_ptr<Instrument> instrument;
    order_type type;
    order_side side;
    time_in_force tif;
    uint64_t account = 0;
    uint64_t user_id = 0;
    uint64_t broker_id = 0;
    double price = std::numeric_limits<double>::quiet_NaN();
    double trigger_price = std::numeric_limits<double>::quiet_NaN();
    int32_t quantity = 0;
    int32_t display_quantity = 0;
};

struct change_request
{
    uint32_t request_id = 0;      
    uint64_t request_time = 0;    
    double price = std::numeric_limits<double>::quiet_NaN();
    double trigger_price = std::numeric_limits<double>::quiet_NaN();
    int32_t quantity = 0;
    int32_t display_quantity = 0;
};

class OrderHandle : public std::enable_shared_from_this<OrderHandle>
{
public:
    explicit OrderHandle (OrderManager& manager, const order_profile& profile);

    explicit OrderHandle (std::unique_ptr<OrderHandleImpl>&&);

    ~OrderHandle (void) noexcept;

    OrderHandle (const OrderHandle&) = delete;
    OrderHandle& operator= (const OrderHandle&) = delete;
    OrderHandle (OrderHandle&&) = delete;
    OrderHandle& operator= (OrderHandle&&) = delete;

    const std::string& GetOrderId (void) const noexcept;

    double GetPrice (void) const noexcept;

    int32_t GetOrderQuantity (void) const noexcept;

    int32_t GetWorkingQuantity (void) const noexcept;

    void ChangeOrder (change_request& request);

    void ChangePrice (double price, uint32_t request_id = 0);

    void ChangeQuantity (int32_t quantity, uint32_t request_id = 0);

    void ChangePriceQuantity (double price, int32_t quantity, uint32_t request_id = 0);

    void DeleteOrder (uint32_t request_id = 0);

private:
    friend class OrderManager;
    friend class OrderManagerImpl;
    friend class SharedOrderManagerImpl;

    std::unique_ptr<OrderHandleImpl> m_impl;
};

class ExecutionReport
{
public:
    explicit ExecutionReport (std::shared_ptr<ExecutionReportImpl>);

    ~ExecutionReport (void) noexcept;

    ExecutionReport (const ExecutionReport&) = default;
    ExecutionReport& operator= (const ExecutionReport&) = default;
    ExecutionReport (ExecutionReport&&) = default;
    ExecutionReport& operator= (ExecutionReport&&) = default;

    bool IsPending (void) const noexcept;
    bool IsFill (void) const noexcept;
    bool IsFullFill (void) const noexcept;
    bool IsDelete (void) const noexcept;
    bool IsReject (void) const noexcept;
    bool IsTriggerActivated (void) const noexcept;

    std::pair<bool, std::string> GetOrderId (void) const noexcept;
    std::pair<bool, std::string> GetExecId (void) const noexcept;
    std::pair<bool, order_status> GetOrderStatus (void) const noexcept;
    std::pair<bool, exec_type> GetExecType (void) const noexcept;
    std::pair<bool, order_type> GetOrderType (void) const noexcept;
    std::pair<bool, order_side> GetSide (void) const noexcept;
    std::pair<bool, time_in_force> GetTimeInForce (void) const noexcept;
    std::pair<bool, double> GetPrice (void) const noexcept;
    std::pair<bool, double> GetTriggerPrice (void) const noexcept;
    std::pair<bool, int32_t> GetOrderQty (void) const noexcept;
    std::pair<bool, int32_t> GetLeavesQty (void) const noexcept;
    std::pair<bool, int32_t> GetCumQty (void) const noexcept;
    std::pair<bool, int32_t> GetDisplayQty (void) const noexcept;
    std::pair<bool, int32_t> GetRefreshQty (void) const noexcept;

    std::pair<bool, double> GetLastFillPrice (void) const noexcept;
    std::pair<bool, int32_t> GetLastFillQty (void) const noexcept;

    std::pair<bool, uint64_t> GetUserId (void) const noexcept;
    std::pair<bool, uint64_t> GetAccountId (void) const noexcept;
    std::pair<bool, std::string> GetAccountName (void) const noexcept;
    std::pair<bool, uint64_t> GetBrokerId (void) const noexcept;

    std::pair<bool, uint64_t> GetInstrumentId (void) const noexcept;
    std::pair<bool, market> GetMarket (void) const noexcept;

    std::pair<bool, ord_rej_reason> GetOrderRejectReason (void) const noexcept;
    std::pair<bool, reject_source> GetRejectSource (void) const noexcept;
    std::pair<bool, reject_code> GetRejectCode (void) const noexcept;
    std::pair<bool, std::string> GetText (void) const noexcept;

private:
    std::shared_ptr<ExecutionReportImpl> m_impl;
};

class OrderCancelReject
{
public:
    explicit OrderCancelReject (std::shared_ptr<OrderCancelRejectImpl>);

    ~OrderCancelReject (void) noexcept;

    OrderCancelReject (const OrderCancelReject&) = default;
    OrderCancelReject& operator= (const OrderCancelReject&) = default;
    OrderCancelReject (OrderCancelReject&&) = default;
    OrderCancelReject& operator= (OrderCancelReject&&) = default;

    std::pair<bool, std::string> GetOrderId (void) const noexcept;
    std::pair<bool, order_status> GetOrderStatus (void) const noexcept;
    std::pair<bool, order_type> GetOrderType (void) const noexcept;
    std::pair<bool, order_side> GetSide (void) const noexcept;
    std::pair<bool, time_in_force> GetTimeInForce (void) const noexcept;

    std::pair<bool, uint64_t> GetUserId (void) const noexcept;
    std::pair<bool, uint64_t> GetAccountId (void) const noexcept;
    std::pair<bool, std::string> GetAccountName (void) const noexcept;
    std::pair<bool, uint64_t> GetBrokerId (void) const noexcept;

    std::pair<bool, uint64_t> GetInstrumentId (void) const noexcept;
    std::pair<bool, market> GetMarket (void) const noexcept;

    std::pair<bool, cxl_rej_reason> GetCancelRejectReason (void) const noexcept;
    std::pair<bool, reject_source> GetRejectSource (void) const noexcept;
    std::pair<bool, reject_code> GetRejectCode (void) const noexcept;
    std::pair<bool, std::string> GetText (void) const noexcept;

private:
    std::shared_ptr<OrderCancelRejectImpl> m_impl;
};

struct execution_report_response
{
    uint32_t request_id = 0;             
    std::shared_ptr<OrderHandle> handle; 
    ExecutionReport er;                  

    execution_report_response (uint32_t, std::shared_ptr<OrderHandle>&,
                               std::shared_ptr<ExecutionReportImpl>);
};

struct order_cancel_reject_response
{
    uint32_t request_id = 0;             
    std::shared_ptr<OrderHandle> handle; 
    OrderCancelReject ocr;               

    order_cancel_reject_response (uint32_t, std::shared_ptr<OrderHandle>&,
                                  std::shared_ptr<OrderCancelRejectImpl>);
};

struct order_timeout_response
{
    uint32_t request_id = 0;             
    std::shared_ptr<OrderHandle> handle; 
};

struct request_failed_response
{
    uint32_t request_id = 0;             
    std::shared_ptr<OrderHandle> handle; 
    std::string message;                 
};

// TODO document
struct fill_receipt
{
    std::string order_id;
    std::string exec_id;
    uint64_t    instrument_id;
    uint64_t    account_id;
    uint64_t    broker_id;
    uint64_t    connection_id;
    double      last_px;
    int32_t     last_qty;
    int32_t     order_qty;
    int32_t     exch_order_qty;
    int32_t     cum_qty;
    int32_t     exch_cum_qty;
    int32_t     leaves_qty;
    int32_t     exch_leaves_qty;
    uint64_t    order_sequence;

    uint64_t order_received_oc;
    uint64_t received_from_exchange;
    uint64_t time_sent;
    uint64_t time_sent_exchange;
};

struct fill_download_response
{
    uint32_t request_id = 0;        
    fill_receipt fill;              
    bool download_complete = false; 
};

struct orderbook_download_response
{
    uint32_t request_id = 0;                        
    std::vector<std::shared_ptr<OrderHandle>> book; 
};

// TODO
struct position_download_response
{
    uint32_t request_id = 0;
};

struct download_failed_response
{
    uint32_t request_id = 0; 
    std::string message;     
};

class OrderEventListener
{
public:
    virtual ~OrderEventListener (void) noexcept = default;

    virtual void OnExecutionReport (const execution_report_response&) = 0;

    virtual void OnOrderCancelReject (const order_cancel_reject_response&) = 0;

    virtual void OnOrderTimeout (const order_timeout_response&) = 0;

    virtual void OnRequestFailed (const request_failed_response&) = 0;

    virtual void OnFillDownload (fill_download_response&&) = 0;

    virtual void OnOrderBookDownload (orderbook_download_response&&) = 0;

    // TODO
    //virtual void OnPositionDownload (const position_download_response&) = 0;

    virtual void OnDownloadFailed (download_failed_response&&) = 0;
};

class OrderManager
{
public:
    OrderManager (void);

    ~OrderManager (void) noexcept;

    OrderManager (const OrderManager&) = delete;
    OrderManager& operator= (const OrderManager&) = delete;
    OrderManager (OrderManager&&) = default;
    OrderManager& operator= (OrderManager&&) = default;

    void Subscribe (const std::shared_ptr<OrderEventListener>& listener) noexcept;

    void PlaceOrder (std::shared_ptr<OrderHandle>& handle, uint32_t request_id = 0);

    void DownloadFills (uint8_t  days = 7,
                        market   market_id = market::INVALID,
                        uint64_t account = 0,
                        uint32_t request_id = 0);

    void DownloadOrderBook (uint32_t request_id = 0);

private:
    friend class OrderHandle;
    std::shared_ptr<OrderManagerImpl> m_impl;
};

} // namespace tt_core_sdk