#include #include "SingleFillHedger.h" #include "ISpreaderManager.h" #include "SpreaderUtils.h" #include "SpreaderOrderUpdateMessage.h" #include "server/sparkd/spreader/hedger/hedger_states/HedgerState.h" #include "server/sparkd/spreader/LegPropertyData.h" namespace bts { namespace orderman { SingleFillHedger::SingleFillHedger(ISpreaderManager& , const LegPropertyData& leg_property_data, bts::orderman::SpreaderOrderBase::ChildOrder order, bts::Price hedge_price, bts::Quantity hedge_quantity, api::Side hedge_side) : // _spreader_manager(spreader_manager), _leg_property_data (leg_property_data), _order (order), _price_quantity_state(hedge_price, hedge_quantity, hedge_side), _curr_state_worker (nullptr) { LOG(OrderMan,Diag,"SingleFillHedger cons, sec {} price {} quantity {} order_key {}", leg_property_data.security_key(), hedge_price.value(), hedge_quantity.value(), order.order_key().value()); transform_to_START (); } bool SingleFillHedger::is_active_order() const { bool is_not_active = _curr_state_worker->state() == HedgerState::START || _curr_state_worker->state() == HedgerState::END; return !is_not_active; } bool SingleFillHedger::is_terminal_state () const { return _curr_state_worker->state() != HedgerState::END; } bool SingleFillHedger::accepting_price_change() const { return _curr_state_worker->state() == HedgerState::WORKING; } Quantity SingleFillHedger::remaining_to_fill() const { return _price_quantity_state.remaining_to_fill(); } void SingleFillHedger::init() { _curr_state_worker->init(); } void SingleFillHedger::on_order_update(const SpreaderOrderUpdateMessage& order_update_message) { _curr_state_worker->on_order_update (order_update_message); } void SingleFillHedger::on_book(TickToTradeCorID corid, const Book& book) { _curr_state_worker->on_book (corid, book); } void SingleFillHedger::cancel_hedge() { _curr_state_worker->cancel (); } void SingleFillHedger::terminate () { _curr_state_worker->terminate(); } void SingleFillHedger::on_time (const bts::TimeStamp& ts) { _curr_state_worker->on_time (ts); } void SingleFillHedger::transform_to_START() { bts_assert (_curr_state_worker == nullptr); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_START order_key {}", _order.order_key().value()); _curr_state_worker = &_start_state_worker; _curr_state_worker->build_once (this); } void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() { bts_assert (_curr_state_worker->state() == HedgerState::START); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK order_key {}", _order.order_key().value()); _curr_state_worker = &_waiting_for_first_ack_state_worker; _curr_state_worker->build_once (this); } void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED () { bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED order_key {}", _order.order_key().value()); _curr_state_worker = &_waiting_for_first_ack_cancelled_state_worker; _curr_state_worker->build_once (this); } void SingleFillHedger::transform_to_WORKING() { bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WORKING order_key {}", _order.order_key().value()); _curr_state_worker = &_working_state_worker; _curr_state_worker->build_once (this); } void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK() { bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED || _curr_state_worker->state() == HedgerState::WORKING); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK order_key {}", _order.order_key().value()); _curr_state_worker = &_waiting_for_cancel_ack_state_worker; _curr_state_worker->build_once (this); } void SingleFillHedger::transform_to_END() { bts_assert (_curr_state_worker->state() != HedgerState::END); LOG(OrderMan, Diag, "SingleFillHedger::transform_to_END order_key {}", _order.order_key().value()); _curr_state_worker = &_end_state_worker; _curr_state_worker->build_once (this); } }}