200 lines
6.6 KiB
C++
200 lines
6.6 KiB
C++
#include "QueueHolderOrder.h"
|
|
#include "lib/domain_model/Security.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/orderman/actors/order_manager/OrderBuilder.h"
|
|
#include "lib/orderman/events/BookUpdateEvent.h"
|
|
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
|
|
#include "lib/os/os.h"
|
|
#include "lib/utils/PBUtils.h"
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include "lib/os/os.h"
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
class SubOrder{
|
|
public:
|
|
ChildOrder order;
|
|
// position in the order list
|
|
uint16_t pos;
|
|
// last sent price
|
|
Price out_price;
|
|
// last send qty
|
|
Quantity out_qty;
|
|
// last received status
|
|
api::orderman::OrderStatus status;
|
|
// total fills
|
|
uint32_t filled_quantity;
|
|
// avg filled price
|
|
double avg_price;
|
|
SubOrder()
|
|
:
|
|
order(),
|
|
out_price(bts::os::nan()),
|
|
out_qty(0),
|
|
status(api::orderman::OrderStatus::ORDER_STATUS_INACTIVE),
|
|
filled_quantity(0),
|
|
avg_price(bts::os::nan())
|
|
{}
|
|
};
|
|
|
|
struct QueueHolderOrder::PImpl {
|
|
OrderServices *services;
|
|
api::orderman::OrderDefinition order_def;
|
|
bool is_recovered;
|
|
bool is_succ_inited;
|
|
double tick_size;
|
|
uint16_t n_orders;
|
|
api::orderman::OrderState state;
|
|
OrderBuilder order_builder;
|
|
Book book;
|
|
//0th entry is the top order (most aggressive)
|
|
std::vector<SubOrder> orders;
|
|
PImpl()
|
|
:
|
|
services(nullptr),
|
|
order_def()
|
|
{}
|
|
};
|
|
|
|
QueueHolderOrder::QueueHolderOrder()
|
|
:
|
|
_state(State::START),
|
|
me(new PImpl()) {}
|
|
QueueHolderOrder::~QueueHolderOrder() {}
|
|
const api::orderman::OrderDefinition &QueueHolderOrder::definition() const {
|
|
return me->order_def;
|
|
}
|
|
void QueueHolderOrder::on_init_new(const api::orderman::OrderDefinition& order_def,
|
|
const PreActivationOrderServices& pre_os) {
|
|
LOG(OrderMan, Info, "QueueHolderOrder::on_init_new key:{} state:{}",
|
|
key(), _state);
|
|
switch (_state) {
|
|
case State::START:
|
|
me->is_succ_inited = _on_init_new(order_def, pre_os);
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::WORKING:
|
|
case State::WAITING_FOR_CANCEL_ALL:
|
|
case State::END:
|
|
std::ostringstream oss;
|
|
oss << "QueueHolderOrder::on_init_new key:" << key() << "state:" << _state;
|
|
bts_assert_msg(false, oss.str());
|
|
break;
|
|
}
|
|
}
|
|
void QueueHolderOrder::on_init_recovered(
|
|
const api::orderman::OrderRecord&,
|
|
const PreActivationOrderServices&) {
|
|
}
|
|
void QueueHolderOrder::on_activate(
|
|
Price price,
|
|
Quantity qty,
|
|
OrderServices& services,
|
|
const trace::CorID&) {
|
|
LOG(OrderMan, Info,
|
|
"QueueHolderOrder::on_activate key:{} state:{} price:{} qty:{}",
|
|
key(), _state, price, qty);
|
|
switch (_state) {
|
|
case State::START:
|
|
me->services = &services;
|
|
me->state.set_price(price.value());
|
|
me->state.set_quantity(qty.value());
|
|
if (me->is_recovered || !me->is_succ_inited)
|
|
_switch_state(State::END);
|
|
else {
|
|
me->order_builder.activate(services);
|
|
for(uint16_t i=0;i<me->n_orders;i++){
|
|
me->orders.emplace_back();
|
|
SubOrder& new_it=me->orders.back();
|
|
new_it.order=me->order_builder.build();
|
|
}
|
|
services.subscribe_to_child_updates(
|
|
[this](const OrderStateUpdateEvent &os) {
|
|
this->_on_child_order_update(os);
|
|
});
|
|
services.subscribe_to_book(SecurityKey(me->order_def.security_key()),
|
|
[this](const BookUpdateEvent &bk_event) {
|
|
this->_on_book_update(bk_event);
|
|
});
|
|
services.subscribe_to_time(
|
|
[this](const bts::mercury::TimerEvent &te) { _on_time(te); });
|
|
_send_initial_orders();
|
|
_switch_state(State::WAITING_FOR_FIRST_ACK);
|
|
}
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::WORKING:
|
|
case State::WAITING_FOR_CANCEL_ALL:
|
|
case State::END: {
|
|
std::ostringstream oss;
|
|
oss << "QueueHolderOrder::on_activate key:" << key() << "state:" << _state;
|
|
bts_assert_msg(false, oss.str());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// order price, qty change
|
|
void QueueHolderOrder::on_update(Price,
|
|
Quantity,
|
|
const trace::CorID&) {
|
|
}
|
|
void QueueHolderOrder::on_crack(trace::CorID const &) {
|
|
}
|
|
void QueueHolderOrder::on_cancel(const trace::CorID&) {
|
|
}
|
|
void QueueHolderOrder::_on_book_update(const BookUpdateEvent&) {
|
|
}
|
|
void QueueHolderOrder::_on_child_order_update(const OrderStateUpdateEvent&) {
|
|
}
|
|
void QueueHolderOrder::_on_time(const bts::mercury::TimerEvent&) {
|
|
}
|
|
bool QueueHolderOrder::_on_init_new(
|
|
const api::orderman::OrderDefinition& order_def,
|
|
const PreActivationOrderServices& pre_os) {
|
|
me->order_def = order_def;
|
|
if (!me->order_def.has_custom_def() ||
|
|
!me->order_def.custom_def().has_queue_holder()) {
|
|
LOG(OrderMan, Error,
|
|
"QueueHolderOrder::_on_init_new key:{} "
|
|
"OrderDefinition does not have QueueHolderDefinition",
|
|
key());
|
|
me->state.set_last_msg("QueueHolderOrder not properly formed");
|
|
return false;
|
|
}
|
|
const bts::api::Security* sec_ptr =
|
|
pre_os.sec_db.resolve(SecurityKey(order_def.security_key()));
|
|
if (sec_ptr==nullptr) {
|
|
LOG(OrderMan, Error,
|
|
"QueueHolderOrder::_on_init_new key:{} state:{} "
|
|
"Could not resolve sec_key:{}",
|
|
key(), _state, order_def.security_key());
|
|
me->state.set_last_msg("Could not resolve Trigger Order security");
|
|
return false;
|
|
}
|
|
const api::orderman::QueueHolderDefinition& qh_def=me->order_def.custom_def().queue_holder();
|
|
api::orderman::OrderDefinition child_order_def = order_def;
|
|
child_order_def.mutable_custom_def()->CopyFrom(qh_def.child());
|
|
me->order_builder = OrderBuilder(key(), child_order_def, pre_os);
|
|
LOG(OrderMan, Info,
|
|
"QueueHolderOrder::_on_init_new key:{} state:{} ",
|
|
key(), _state);
|
|
return true;
|
|
}
|
|
void QueueHolderOrder::_send_initial_orders(){
|
|
double mult = me->order_def.side()==api::Side::SIDE_BUY ? -1 : 1;
|
|
for(uint16_t i=0;i<me->n_orders;i++){
|
|
double price=me->state.price()+mult*i*me->tick_size;
|
|
SubOrder& order=me->orders.at(i);
|
|
order.order.activate(Price(price),Quantity(me->state.quantity()));
|
|
}
|
|
}
|
|
void QueueHolderOrder::_report_state() {
|
|
}
|
|
void QueueHolderOrder::_switch_state(State) {
|
|
}
|
|
|
|
} // namespace orderman
|
|
} // namespace bts
|