#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 #include #include "lib/os/os.h" namespace bts { namespace orderman { QueueHolderOrder::QueueHolderOrder() : _is_succ_inited(false), _is_recovered(false), _termination_reason(TerminationReason::NONE), _order_def(), _tick_size(bts::os::nan()), _order_builder(), _order_manager(), _services(nullptr), _reported_state(), _sent_state(), _book(), _state_worker(nullptr), _start_state_worker(this), _waiting_for_ack_state_worker(this), _working_state_worker(this), _waiting_for_cancel_all_state_worker(this), _end_state_worker(this){ _switch_state(QueueHolderOrderState::START); } QueueHolderOrder::~QueueHolderOrder() {} const api::orderman::OrderDefinition& QueueHolderOrder::definition() const { return _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_int()); _state_worker->on_init_new(order_def,pre_os); } void QueueHolderOrder::on_init_recovered( const api::orderman::OrderRecord& rec, const PreActivationOrderServices& pre_os) { LOG(OrderMan, Info, "QueueHolderOrder::on_init_recovered key:{} state:{}", key(), _state_int()); _state_worker->on_init_recovered(rec,pre_os); } OrderOpResult QueueHolderOrder::on_activate(Price price, Quantity qty, OrderServices& services) { LOG(OrderMan, Info, "QueueHolderOrder::on_activate key:{} state:{} price:{} qty:{}", key(), _state_int(), price, qty); _state_worker->on_activate(price,qty,services); _report_state(); return OrderOpResult {}; } // order price, qty change OrderOpResult QueueHolderOrder::on_update(Price price, Quantity qty) { _state_worker->on_update(price,qty); _report_state(); return OrderOpResult {}; } OrderOpResult QueueHolderOrder::on_cancel() { LOG(OrderMan, Info, "QueueHolderOrder::on_cancel key:{} state:{}", key(), _state_int()); _state_worker->on_cancel(); _report_state(); return OrderOpResult {}; } OrderOpResult QueueHolderOrder::on_detach() { return OrderOpResult {}; } void QueueHolderOrder::_on_book_update(const BookUpdateEvent& b) { _state_worker->on_book(b.book,b.trace); } void QueueHolderOrder::_on_child_order_update( const OrderStateUpdateEvent& c) { _state_worker->on_child_order_update(c); _report_state(); } void QueueHolderOrder::_on_time(const bts::mercury::TimerEvent& te) { _state_worker->on_time(te.ts); } void QueueHolderOrder::_switch_state(QueueHolderOrderState new_state) { int s0=_state_int(); switch (new_state){ case QueueHolderOrderState::START: bts_assert(_state_worker==nullptr); _state_worker=&_start_state_worker; break; case QueueHolderOrderState::WAITING_FOR_FIRST_ACK: bts_assert(_state_worker->state()==QueueHolderOrderState::START || _state_worker->state()==QueueHolderOrderState::WORKING); _state_worker=&_waiting_for_ack_state_worker; break; case QueueHolderOrderState::WORKING: bts_assert(_state_worker->state()== QueueHolderOrderState::WAITING_FOR_FIRST_ACK); _state_worker=&_working_state_worker; break; case QueueHolderOrderState::WAITING_FOR_CANCEL_ALL: bts_assert(_state_worker->state()== QueueHolderOrderState::WAITING_FOR_FIRST_ACK || _state_worker->state()== QueueHolderOrderState::WORKING); _state_worker=&_waiting_for_cancel_all_state_worker; break; case QueueHolderOrderState::END: bts_assert(_state_worker->state()!=QueueHolderOrderState::END); _state_worker=&_end_state_worker; break; } _state_worker->on_transition(); _report_state(); LOG(OrderMan, Info, "QueueHolderOrder::_switch_state key:{} {}->{}", key(), s0,_state_int()); } api::orderman::OrderStatus QueueHolderOrder::_status(std::string& message) const{ QueueHolderOrderState curr_state= _state_worker==nullptr?QueueHolderOrderState::START:_state(); switch (curr_state){ case QueueHolderOrderState::START: case QueueHolderOrderState::WAITING_FOR_FIRST_ACK: case QueueHolderOrderState::WORKING: case QueueHolderOrderState::WAITING_FOR_CANCEL_ALL: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case QueueHolderOrderState::END: switch(_termination_reason){ case TerminationReason::NONE:{ // this will happen if the order is // recovered or the init failed bts_assert(!_is_succ_inited||_is_recovered); if(!_is_succ_inited){ message="Could not initialize order"; return api::orderman::OrderStatus::ORDER_STATUS_REJECTED_BY_SPARK; } else{ message="Recovered order"; // we could have done better here by [reserving ] return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; } } case TerminationReason::EXTERNAL_CANCEL: return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; case TerminationReason::FILLED: return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; case TerminationReason::UNEXPECTED_CHILD_CANCEL: message="Child order cancelled"; return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; case TerminationReason::CHILD_ERROR: message="Child order error"; return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; } } return api::orderman::OrderStatus::ORDER_STATUS_WORKING; } } // namespace orderman } // namespace bts