order_book.h

Go to the documentation of this file.

 
#pragma once
#include "order_fwd.h"
#include <props/props.h>
#include <logger/xroad_logger.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef enum
{
   order_book_state_initial                  = 0, 
   order_book_state_active                   = 1, 
   order_book_state_destroyed                = 2, 
   order_book_state_canceled                 = 3, 
   order_book_state_rejected                 = 4, 
   order_book_state_awaiting_active          = 5, 
   order_book_state_awaiting_destroy         = 6, 
   order_book_state_awaiting_cancel          = 7, 
   order_book_state_awaiting_replace         = 8, 
   order_book_state_awaiting_reject          = 9, 
   order_book_state_error                    = 10, 
   order_book_state_awaiting_cancel_replace  = 11  
} order_book_state_t;
 
typedef struct
{
   bool (*on_can_send)(order_book_t*);  
   void (*on_activated)(order_book_t*); 
   void (*on_canceled)(order_book_t*);  
   void (*on_rejected)(order_book_t*, xroad_rej_reason_t, xroad_str_t);  
   void (*on_replaced)(order_book_t*);  
   void (*on_error)(order_book_t*, xroad_str_t);   
   void (*on_trade)(order_book_t*, xroad_trade_t*);  
   void (*on_destroyed)(order_book_t*);  
   xroad_errno_t (*gen_qty)(order_book_t*, uint64_t, xroad_side_t, xroad_qty_t*, size_t, xroad_sstream_t*); 
   void* ctx;   
} order_book_callback_t;
 
typedef enum
{
   order_book_side_none  = 0,
   order_book_side_buy   = 1,
   order_book_side_sell  = 2,
   order_book_side_both  = 3
} order_book_side_t;
 
typedef enum
{
   order_book_replace_best_bid = 1, 
   order_book_replace_best_ask = 2, 
   order_book_replace_size     = 4, 
   order_book_replace_side     = 8  
} order_book_replace_mask_t;
 
typedef struct
{
   xroad_price_t     best_bid;
   xroad_price_t     best_ask;
   xroad_qty_t       size;
   order_book_side_t side;
   xroad_sstream_t*  ss;
} order_book_replace_args_t;
 
typedef struct
{
   uint32_t                levels;
   order_book_side_t       side;
   xroad_price_t           best_bid;
   xroad_price_t           best_ask;
   uint32_t                price_step;
   xroad_str_t             trader_book;
   xroad_str_t             account_buy;
   xroad_str_t             account_sell;
   xroad_str_t             client_code_buy;
   xroad_str_t             client_code_sell;
   xroad_broker_t*         broker_buy;
   xroad_broker_t*         broker_sell;
   order_book_callback_t   cback;
   xroad_logger_t*         logger;
   xroad_sstream_t*        ss;
   int32_t                 flags;
   int32_t                 order_flags;
   xroad_currency_t*       hedge_currency;
   uint32_t                destroy_timeout_ms;
} order_book_create_args_t;
 
typedef struct
{
   bool force;
} order_book_destroy_args_t;
 
xroad_str_t order_book_state_to_str(order_book_state_t state);
 
xroad_str_t order_book_side_to_str(order_book_side_t side);
 
#define order_book_create(instr, size, ...)                                                                       \
({                                                                                                                \
   order_book_create_args_t args = {.levels = 1, .price_step = 1U, .destroy_timeout_ms = 5000, ## __VA_ARGS__};   \
   order_book_create_ex(instr, size, args.levels, args.side, args.best_bid, args.best_ask,                        \
         args.price_step, args.trader_book, args.account_buy, args.account_sell,                                  \
         args.client_code_buy, args.client_code_sell, args.broker_buy, args.broker_sell,                          \
         args.cback, args.logger, args.ss, args.flags, args.order_flags, args.hedge_currency,                     \
         args.destroy_timeout_ms);                                                                                \
})
 
order_book_t* order_book_create_ex(
      xroad_instr_t* instr,
      xroad_qty_t size,
      uint32_t levels,
      order_book_side_t side,
      xroad_price_t best_bid,
      xroad_price_t best_ask,
      uint32_t price_step,
      xroad_str_t trader_order_book,
      xroad_str_t account_buy,
      xroad_str_t account_sell,
      xroad_str_t client_code_buy,
      xroad_str_t client_code_sell,
      xroad_broker_t* broker_buy,
      xroad_broker_t* broker_sell,
      order_book_callback_t cback,
      xroad_logger_t* logger,
      xroad_sstream_t* ss,
      int32_t flags,
      int32_t order_flags,
      xroad_currency_t* hedge_currency,
      uint32_t destroy_timeout_ms);
 
void order_book_print(order_book_t* order_book);
 
xroad_instr_t* order_book_get_instr(order_book_t* order_book);
 
xroad_price_t order_book_get_size(order_book_t* order_book);
 
void* order_book_get_ctx(order_book_t*);
 
const order_t* order_book_get_order(order_book_t* order_book, order_book_side_t side, uint32_t idx);
 
xroad_errno_t order_book_replace_ex(
      order_book_t* order_book,
      xroad_qty_t size,
      order_book_side_t side,
      xroad_price_t best_bid,
      xroad_price_t best_ask,
      int32_t mask,
      xroad_sstream_t* ss);
 
#define order_book_replace(order_book, ...)                                                                           \
({                                                                                                                    \
   xroad_qty_t def_size = -99999999999;                                                                               \
   xroad_price_t def_price = - 99999999999.0;                                                                         \
   order_book_replace_args_t args = (order_book_replace_args_t){                                                      \
      .size = def_size, .best_bid = def_price, .best_ask = def_price, .side = (order_book_side_t)-1, ## __VA_ARGS__}; \
   int32_t mask = 0;                                                                                                  \
   mask |= !xroad_dbl_cmp(args.best_bid, def_price) ? 0 : order_book_replace_best_bid;                                \
   mask |= !xroad_dbl_cmp(args.best_ask, def_price) ? 0 : order_book_replace_best_ask;                                \
   mask |= args.side == (order_book_side_t)-1 ? 0 : order_book_replace_side;                                          \
   mask |= args.size == def_size ? 0 : order_book_replace_size;                                                       \
   order_book_replace_ex(order_book, args.size, args.side, args.best_bid, args.best_ask, mask, args.ss);              \
})
 
xroad_errno_t order_book_send(order_book_t* order_book);
 
xroad_errno_t order_book_cancel(order_book_t* order_book);
 
#define order_book_destroy(book, ...)                                               \
({                                                                                  \
   order_book_destroy_args_t args = (order_book_destroy_args_t){__VA_ARGS__};       \
   order_book_destroy_ex(book, args.force);                                         \
})
 
void order_book_destroy_ex(order_book_t* order_book, bool force);
 
order_book_state_t order_book_get_state(order_book_t* order_book);
 
#ifdef __cplusplus
}
#endif