order.h

Go to the documentation of this file.

 
#pragma once
 
#include "order_fwd.h"
#include <common/xroad_string.h>
#include <common/xroad_date.h>
#include <cache/xroad_objects.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef enum
{
   order_state_initial           = 0,  
   order_state_active            = 1,  
   order_state_destroyed         = 2,  
   order_state_canceled          = 3,  
   order_state_rejected          = 4,  
   order_state_filled            = 5,  
   order_state_expired           = 6,  
   order_state_awaiting_active   = 7,  
   order_state_awaiting_destroy  = 8,  
   order_state_awaiting_cancel   = 9,  
   order_state_awaiting_replace  = 10  
} order_state_t;
 
typedef enum
{
   order_exec_check_role    = 1,
   order_exec_delay_replace = 2,
   order_exec_fix_qty       = 4,
   order_exec_replace_send  = 8
} order_exec_t;
 
typedef enum
{
   order_replace_qty   = 1, 
   order_replace_price = 2, 
} order_replace_mask_t;
 
xroad_str_t order_state_to_str(order_state_t state);
 
typedef struct
{
   xroad_qty_t qty;
   xroad_price_t price;
} order_replace_args_t;
 
typedef struct
{
   xroad_str_t      name;
   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      trader_book;
   int32_t          flags;
   xroad_tif_t      tif;
   xroad_date_t     till_date;
   uint32_t         max_cancel_attempts;
   uint32_t         cancel_timeout_ms;
   int32_t          exec_flags;
   xroad_str_t      comment;
   void*            ctx;
   xroad_str_t*     err;
} order_create_args_t;
 
typedef struct
{
   bool send;
} order_cancel_args_t;
 
typedef struct
{
   void (*on_activated)(order_t*, xroad_str_t, xroad_timestamp_t);
   void (*on_before_send)(order_t*);
   bool (*on_can_send)(order_t*, xroad_qty_t, xroad_price_t);
   void (*on_trade)(order_t*, xroad_trade_t*);
   void (*on_canceled)(order_t*, xroad_rej_reason_t reason, xroad_str_t);
   void (*on_unexpected_canceled)(order_t*, xroad_rej_reason_t reason, xroad_str_t);
   void (*on_destroyed)(order_t*);
   void (*on_replaced)(order_t*, xroad_str_t, xroad_timestamp_t);
   void (*on_rejected)(order_t*, xroad_rej_reason_t, xroad_str_t);
   void (*on_cancel_rejected)(order_t*, xroad_rej_reason_t, xroad_str_t);
   void (*on_replace_rejected)(order_t*, xroad_rej_reason_t, xroad_str_t);
   void (*on_pre_trade)(order_t*, xroad_pre_trade_t*);
} order_callback_t;
 
order_t* order_create_ex(
      xroad_instr_t*   instr,
      xroad_side_t     side,
      order_callback_t callback,
      xroad_str_t      name,
      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      trader_book,
      int32_t          flags,
      xroad_tif_t      tif,
      xroad_date_t     till_date,
      uint32_t         max_cancel_attempts,
      uint32_t         cancel_timeout_ms,
      int32_t          exec_flags,
      xroad_str_t      comment,
      void*            ctx,
      xroad_str_t*     err);
 
#define order_create(instr, side, callback, ...)                                                                      \
({                                                                                                                    \
   xroad_str_t def_account = xroad_str("XXXX");                                                                       \
   order_create_args_t args = {.account = def_account, .type = xroad_ord_type_limit, .tif = xroad_tif_day,            \
                              __VA_ARGS__};                                                                           \
   if (args.till_date.year == 0 && args.till_date.month == 0 && args.till_date.day == 0)                              \
   {                                                                                                                  \
      args.till_date = xroad_date_null;                                                                               \
   }                                                                                                                  \
   order_create_ex(instr, side, callback, args.name, args.account, args.client_code, args.type, args.qty,             \
         args.price, args.trader_book, args.flags, args.tif, args.till_date, args.max_cancel_attempts,                \
         args.cancel_timeout_ms, args.exec_flags, args.comment, args.ctx, args.err);                                  \
})
 
xroad_errno_t order_destroy(order_t* o, bool force);
 
xroad_errno_t order_restore(order_t* o, xroad_order_t* xo);
 
xroad_errno_t order_send(order_t* o);
 
xroad_errno_t order_cancel_ex(order_t* o, bool send);
 
xroad_errno_t order_pre_trade_ack(order_t* o, xroad_pre_trade_t* pre_trade, xroad_pre_trade_status_t status);
 
#define order_cancel(o, ...)                                   \
({                                                             \
   order_cancel_args_t args = {.send = true, ## __VA_ARGS__};  \
   order_cancel_ex(o, args.send);                              \
})
 
xroad_errno_t order_replace_ex(
      order_t* o,
      xroad_qty_t qty,
      xroad_price_t price,
      int32_t mask);
 
#define order_replace(o, ...)                                                                               \
({                                                                                                          \
   xroad_qty_t def_qty = -99999;                                                                            \
   xroad_price_t def_price = -99999.0;                                                                      \
   order_replace_args_t args = (order_replace_args_t){.qty = def_qty, .price = def_price, ## __VA_ARGS__};  \
   int32_t mask = 0;                                                                                        \
   mask |= (args.qty == def_qty) ? 0 : order_replace_qty;                                                   \
   mask |= !xroad_dbl_cmp(args.price, def_price) ? 0 : order_replace_price;                                 \
   order_replace_ex(o, args.qty, args.price, mask);                                                         \
})
 
void order_reset(order_t* o);
 
xroad_str_t order_get_name(const order_t* o);
 
xroad_instr_t* order_get_instr(const order_t* o);
 
xroad_side_t order_get_side(const order_t* o);
 
xroad_qty_t order_get_qty(const order_t* o);
 
xroad_qty_t order_get_leaves_qty(const order_t* o);
 
xroad_price_t order_get_price(const order_t* o);
 
xroad_price_t order_get_replace_price(const order_t* o);
 
xroad_qty_t order_get_replace_qty(const order_t* o);
 
void* order_get_ctx(const order_t* o);
 
order_state_t order_get_state(const order_t* o);
 
xroad_qty_t order_get_total_qty(const order_t* o);
 
xroad_price_t order_get_avg_price(const order_t* o);
 
xroad_ord_type_t order_get_type(const order_t* o);
 
xroad_str_t order_print(const order_t* o);
 
xroad_order_t* order_get_xorder(const order_t* o);
 
int32_t order_get_flags(const order_t* o);
 
void order_log_debug(order_t* o, char* title);
 
uint64_t* order_trace_init(xroad_str_t path, size_t max_rec);
 
#ifdef __cplusplus
}
#endif