Files
spark/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp
T

167 lines
6.4 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 {
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