Files
spark/src/server/sparkd/spreader/SingleFillHedger.cpp
T

177 lines
7.2 KiB
C++

#include <memory>
#include "SingleFillHedger.h"
#include "ISpreaderManager.h"
#include "SpreaderUtils.h"
namespace bts {
namespace spreader {
SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager,
size_t leg_index,
const OrderTemplate& order_template,
const LegPropertyData& leg_property_data,
bts::Price hedge_price,
bts::Quantity hedge_quantity,
api::BuySell hedge_side)
:
_spreader_manager(spreader_manager),
_leg_index (leg_index),
_order_template (order_template),
_leg_property_data (leg_property_data),
_price_quantity_state(hedge_price, hedge_quantity, hedge_side),
_state(HedgerState::START)
{
}
bool SingleFillHedger::is_active() { return _state != HedgerState::START && _state != HedgerState::END; }
bool SingleFillHedger::accepting_price_change() { return _state == HedgerState::WORKING; }
Quantity SingleFillHedger::remaining_to_fill() { return _price_quantity_state.remaining_to_fill(); }
void SingleFillHedger::update_order_state(const OrderState& order_state)
{
SingleFillHedger::EventData event_data (&order_state);
_fire_event(event_data);
}
void SingleFillHedger::update_md()
{
SingleFillHedger::EventData event_data(ExternalHedgerEvents::MDUpdate);
_fire_event(event_data);
}
void SingleFillHedger::modify_hedge_price(Price new_hedge_price)
{
SingleFillHedger::EventData event_data(new_hedge_price);
_fire_event(event_data);
}
void SingleFillHedger::cancel_hedge()
{
SingleFillHedger::EventData event_data(ExternalHedgerEvents::HedgeCancel);
_fire_event(event_data);
}
/***************************************************************************/
/********************External Event Handling in START***********************/
/***************************************************************************/
void SingleFillHedger::_handle_events_in_START(const EventData&)
{
// start can get no events
bts_assert(false);
}
/***************************************************************************/
/*********External Event Handling in WAITING_FOR_FIRST_ACK******************/
/***************************************************************************/
void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK()
{
bts_assert(_state == HedgerState::START);
_state = HedgerState::WAITING_FOR_FIRST_ACK;
// The order is sent for the one and only time here
// TODO check for market orders pre hedge rule
_order_key = _spreader_manager.send_limit_order(_order_template, _price_quantity_state.target_price(), _price_quantity_state.target_quantity());
}
void SingleFillHedger::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data)
{
if (event_data.external_event == ExternalHedgerEvents::OrderState)
{
bool filled, terminal_status, encountered_error, new_fills;
SpreaderUtils::parse_order(*event_data.order_state, _price_quantity_state.aggregated_filled_quantity(), filled, terminal_status, encountered_error, new_fills);
if (terminal_status)
transform_to_END();
else if (encountered_error)
transform_to_WAITING_FOR_CANCEL_ACK();
else
_transform_to_WORKING();
}
else if (event_data.external_event == ExternalHedgerEvents::MDUpdate) {}
// md will have no impact when waiting for order ack
else if (event_data.external_event == ExternalHedgerEvents::UserHedgePriceChange)
// accept_changes should have returned false, forbiding price changes
bts_assert(false);
else if (event_data.external_event == ExternalHedgerEvents::HedgeCancel)
transform_to_WAITING_FOR_CANCEL_ACK();
}
/***************************************************************************/
/*******************External Event Handling in WORKING**********************/
/***************************************************************************/
void SingleFillHedger::_transform_to_WORKING()
{
bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK);
_state = HedgerState::WORKING;
// nothing to do here, since any changes in the previous
// state were rejected
}
void SingleFillHedger::_handle_events_in_WORKING(const EventData& event_data)
{
if (event_data.external_event == ExternalHedgerEvents::OrderState)
{
bool filled, terminal_status, encountered_error, new_fills;
SpreaderUtils::parse_order(*event_data.order_state, _price_quantity_state.aggregated_filled_quantity(), filled, terminal_status, encountered_error, new_fills);
if (terminal_status)
transform_to_END();
else if (encountered_error)
transform_to_WAITING_FOR_CANCEL_ACK();
}
else if (event_data.external_event == ExternalHedgerEvents::MDUpdate)
{
// TODO apply post hedge rule
}
else if (event_data.external_event == ExternalHedgerEvents::UserHedgePriceChange)
{
_price_quantity_state.udpate_target_price(event_data.hedge_price);
_spreader_manager.update_order(_order_key, _price_quantity_state.target_price(), _price_quantity_state.target_quantity());
}
else if (event_data.external_event == ExternalHedgerEvents::HedgeCancel)
transform_to_WAITING_FOR_CANCEL_ACK();
}
/***************************************************************************/
/*********External Event Handling in WAITING_FOR_CANCEL_ACK*****************/
/***************************************************************************/
void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK()
{
bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK || _state == HedgerState::WORKING);
_state = HedgerState::WAITING_FOR_CANCEL_ACK;
_spreader_manager.cancel_order(_order_key);
}
void SingleFillHedger::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data)
{
if (event_data.external_event == ExternalHedgerEvents::OrderState)
{
bool filled, terminal_status, encountered_error, new_fills;
SpreaderUtils::parse_order(*event_data.order_state, _price_quantity_state.aggregated_filled_quantity(), filled, terminal_status, encountered_error, new_fills);
if (terminal_status)
transform_to_END();
}
}
/***************************************************************************/
/*********************External Event Handling in END************************/
/***************************************************************************/
void SingleFillHedger::transform_to_END()
{
bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK || _state == HedgerState::WORKING);
_state = HedgerState::END;
}
void SingleFillHedger::_handle_events_in_END(const EventData&)
{
}
void SingleFillHedger::_fire_event(const EventData& event_data)
{
if (_state == HedgerState::START)
_handle_events_in_START(event_data);
else if (_state == HedgerState::WAITING_FOR_FIRST_ACK)
_handle_events_in_WAITING_FOR_FIRST_ACK(event_data);
else if (_state == HedgerState::WORKING)
_handle_events_in_WORKING(event_data);
else if (_state == HedgerState::WAITING_FOR_CANCEL_ACK)
_handle_events_in_WAITING_FOR_CANCEL_ACK(event_data);
else if (_state == HedgerState::END)
_handle_events_in_END(event_data);
}
}}