177 lines
7.2 KiB
C++
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);
|
|
}
|
|
|
|
}}
|