strategy.h

Go to the documentation of this file.

 
#pragma once
 
#include <common/xroad_xml.h>
#include <cache/xroad_objects.h>
#include <mdata/engine/mdata_engine.h>
#include <order/order.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define ST_PREV_QTY 0
#define ST_PREV_PRICE 0.0
 
typedef struct strategy_s strategy_t;
 
typedef struct
{
   xroad_instr_t* instr;
   xroad_str_t account;
   xroad_side_t side;
   bool use_native;
} strategy_cancel_orders_args_t;
 
typedef struct
{
   xroad_qty_t qty;
   xroad_price_t price;
} strategy_send_order_ex_args_t;
 
typedef struct
{
   xroad_str_t      account;
   xroad_str_t      client_code;
   xroad_ord_type_t type;
   xroad_qty_t      qty;
   xroad_price_t    price;
   xroad_str_t      ext_ref;
   int32_t          flags;
   xroad_tif_t      tif;
   xroad_date_t     till_date;
} strategy_add_order_ex_args_t;
 
typedef struct
{
   void* ctx;
   void (*on_mdata_trade)(strategy_t*, xroad_instr_t*, const mdata_trade_t*, void*);
   void (*on_mdata_quote)(strategy_t*, xroad_instr_t*, const mdata_quote_t*, void*);
   void (*on_mdata_book)(strategy_t*, xroad_instr_t*, const mdata_book_20_t*, void*);
   void (*on_mdata_common)(strategy_t*, xroad_instr_t*, const mdata_common_info_t*, void*);
   void (*on_mdata_order)(strategy_t*, xroad_instr_t*, const mdata_order_t*, void*);
   void (*on_mdata_feed_state)(strategy_t*, xroad_instr_t*, const mdata_feed_state_type_t, void*);
   void (*on_order_before_send)(strategy_t*, order_t*, void* ctx);
   void (*on_order_activated)(strategy_t*, order_t*, void* ctx);
   void (*on_order_trade)(strategy_t*, order_t*, xroad_trade_t*, void* ctx);
   void (*on_order_canceled)(strategy_t*, order_t*, xroad_rej_reason_t, xroad_str_t, void*);
   void (*on_order_canceled_unexpected)(strategy_t*, order_t*, xroad_rej_reason_t, xroad_str_t, void*);
   void (*on_order_replaced)(strategy_t*, order_t*, void*);
   void (*on_order_rejected)(strategy_t*, order_t*, xroad_rej_reason_t, xroad_str_t, void*);
   void (*on_order_cancel_rejected)(strategy_t*, order_t*, xroad_rej_reason_t, xroad_str_t, void*);
   void (*on_order_replace_rejected)(strategy_t*, order_t*, xroad_rej_reason_t, xroad_str_t, void*);
   void (*on_pos_updated)(strategy_t*, xroad_instr_t*, xroad_price_t, xroad_qty_t, xroad_price_t, xroad_price_t, void*);
   void (*on_order_destroyed)(strategy_t*, order_t*, void*);
   xroad_errno_t (*on_order_restore)(strategy_t*, order_t*, xroad_order_t*, void*);
} strategy_callback_t;
 
strategy_t* strategy_create(xroad_xml_tag_t cfg, strategy_callback_t cback);
 
void strategy_destroy(strategy_t* s);
 
xroad_errno_t strategy_start(strategy_t* s);
 
xroad_errno_t strategy_stop(strategy_t* s);
 
xroad_errno_t strategy_subscribe(strategy_t* s, xroad_instr_t* i, int32_t mask);
 
xroad_errno_t strategy_unsubscribe(strategy_t* s, xroad_instr_t* i);
 
order_t* strategy_add_order_ex(
      strategy_t*      s,
      xroad_str_t      name,
      xroad_instr_t*   instr,
      xroad_side_t     side,
      xroad_str_t      account,
      xroad_str_t      client_code,
      xroad_ord_type_t type,
      xroad_qty_t      qty,
      xroad_price_t    price,
      xroad_str_t      ext_ref,
      int32_t          flags,
      xroad_tif_t      tif,
      xroad_date_t     till_date);
 
#define strategy_add_order(s, name, instr, side, ...)                                                             \
({                                                                                                                \
   xroad_str_t def_account = xroad_str("XXX");                                                                    \
   strategy_add_order_ex_args_t args = {.account = def_account, .type = xroad_ord_type_limit,                     \
         .tif = xroad_tif_day, .till_date = xroad_date_nul, __VA_ARGS__};                                         \
   strategy_add_order_ex(s, name, instr, side, args.account, args.client_code, args.type, args.qty, args.price,   \
            args.ext_ref, args.flags, args.tif, args.till_date);                                                  \
})
 
order_t* strategy_replace_order_ex(
      strategy_t*      s,
      xroad_str_t      name,
      xroad_instr_t*   instr,
      xroad_side_t     side,
      xroad_str_t      account,
      xroad_str_t      client_code,
      xroad_ord_type_t type,
      xroad_qty_t      qty,
      xroad_price_t    price,
      xroad_str_t      ext_ref,
      int32_t          flags,
      xroad_tif_t      tif,
      xroad_date_t     till_date);
 
#define strategy_replace_order(s, name, instr, side, ...)                                                            \
({                                                                                                                   \
   xroad_str_t def_account = xroad_str("XXX");                                                                       \
   strategy_add_order_ex_args_t args = {.account = def_account, .type = xroad_ord_type_limit,                        \
         .tif = xroad_tif_day, .till_date = xroad_date_null, __VA_ARGS__};                                           \
   strategy_replace_order_ex(s, name, instr, side, args.account, args.client_code, args.type, args.qty, args.price,  \
            args.ext_ref, args.flags, args.tif, args.till_date);                                                     \
})
 
 
xroad_errno_t strategy_del_order(strategy_t* s, xroad_str_t oname);
 
order_t* strategy_get_order(strategy_t* s, xroad_str_t oname);
 
order_state_t strategy_get_order_state(strategy_t* s, xroad_str_t oname);
 
xroad_errno_t strategy_send_order_ex(strategy_t* s, xroad_str_t oname, xroad_qty_t qty, xroad_price_t price);
 
#define strategy_send_order(s, oname, ...)                                     \
({                                                                             \
   strategy_send_order_ex_args_t args = (strategy_send_order_ex_args_t){       \
                     .qty = ST_PREV_QTY, .price = ST_PREV_PRICE, __VA_ARGS__}; \
   strategy_send_order_ex(s, oname, args.qty, args.price);                     \
})
 
xroad_errno_t strategy_cancel_order(strategy_t* s, xroad_str_t oname);
 
void strategy_init_orders(strategy_t* s, xroad_instr_t* instr, xroad_str_t account, xroad_str_t client_code);
 
void strategy_init_orders_ex(strategy_t* s, xroad_instr_t* instr, xroad_str_t account, xroad_str_t client_code, xroad_str_t ext_ref);
 
xroad_errno_t strategy_send_order_instr(
      strategy_t* s, const xroad_instr_t* i, xroad_side_t side, xroad_qty_t qty, xroad_price_t price);
 
xroad_errno_t strategy_cancel_orders_ex(
      strategy_t* s, xroad_instr_t* i, xroad_str_t account, xroad_side_t side, bool use_native);
 
#define strategy_cancel_orders(s, ...)                                                       \
({                                                                                           \
   strategy_cancel_orders_args_t args_ = (strategy_cancel_orders_args_t){.instr = NULL,      \
   .side = xroad_side_undef, .use_native = false, __VA_ARGS__};                              \
   strategy_cancel_orders_ex(s, args_.instr, args_.account, args_.side, args_.use_native);   \
 })
 
xroad_str_t strategy_gen_order_name(const xroad_instr_t* i, xroad_side_t side, xroad_ord_type_t type);
 
/*
 * reset current position
 * @param[in] s - strategy instance
 * @param[in] i - instrument
 * @param[in] avg_price -  average price
 * @param[in] qty - current qty(negative for short)
 * @param[in] realized_pnl - realized pnl
 * @return XROAD_OK on success, otherwise XROAD_FAILED
 */
xroad_errno_t strategy_reset_position(strategy_t* s, xroad_instr_t* i, xroad_price_t avg_price, xroad_qty_t qty, xroad_price_t realized_pnl);
 
/*
 * gets instance of mdata_engine
 * @param[in] s - strategy instance
 */
mdata_engine_t* strategy_get_mdata(strategy_t* s);
#ifdef __cplusplus
}
#endif