Merged
This commit is contained in:
commit
fbeeefe7cf
20 files changed
+356
-319
No files matched your search
@@ -1 +1 @@
|
||||
set(sources ;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/Market.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/SpreaderOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/native_orders/NativeOrderFactory.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/spreader_orders/SpreaderOrderBase.cpp;orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp)
|
||||
set(sources ;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/Application.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/Market.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/SpreaderOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/native_orders/NativeOrderFactory.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/spreader_orders/SpreaderOrderBase.cpp;orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp)
|
||||
@@ -3,177 +3,104 @@
|
||||
#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& ,
|
||||
bts::orderman::SpreaderOrderBase::ChildOrder,
|
||||
SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager,
|
||||
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),
|
||||
_spreader_manager(spreader_manager),
|
||||
_leg_property_data (leg_property_data),
|
||||
_order (order),
|
||||
_price_quantity_state(hedge_price, hedge_quantity, hedge_side),
|
||||
_state(HedgerState::START),
|
||||
_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();
|
||||
transform_to_WAITING_FOR_FIRST_ACK();
|
||||
}
|
||||
|
||||
bool SingleFillHedger::is_active_order() const { return _state != HedgerState::START && _state != HedgerState::END; }
|
||||
|
||||
bool SingleFillHedger::is_terminal_state () const {return _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::on_order_update(const SpreaderOrderUpdateMessage& order_update_message)
|
||||
{
|
||||
SingleFillHedger::EventData event_data (&order_update_message);
|
||||
_fire_event(event_data);
|
||||
_curr_state_worker->on_order_update (order_update_message);
|
||||
}
|
||||
|
||||
void SingleFillHedger::on_book(TickToTradeCorID, const Book&)
|
||||
void SingleFillHedger::on_book(TickToTradeCorID corid, const Book& book)
|
||||
{
|
||||
SingleFillHedger::EventData event_data(ExternalHedgerEvents::MDUpdate);
|
||||
_fire_event(event_data);
|
||||
_curr_state_worker->on_book (corid, book);
|
||||
}
|
||||
|
||||
void SingleFillHedger::cancel_hedge()
|
||||
{
|
||||
SingleFillHedger::EventData event_data(ExternalHedgerEvents::HedgeCancel);
|
||||
_fire_event(event_data);
|
||||
_curr_state_worker->cancel ();
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
/********************External Event Handling in START***********************/
|
||||
/***************************************************************************/
|
||||
void SingleFillHedger::_handle_events_in_START(const EventData&)
|
||||
void SingleFillHedger::terminate ()
|
||||
{
|
||||
// start can get no events
|
||||
bts_assert(false);
|
||||
_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);
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
/*********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());
|
||||
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::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data)
|
||||
void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED ()
|
||||
{
|
||||
if (event_data.external_event == ExternalHedgerEvents::OrderState)
|
||||
{
|
||||
const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state);
|
||||
if (update_message.terminal_status())
|
||||
transform_to_END();
|
||||
else if (update_message.has_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();
|
||||
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);
|
||||
}
|
||||
/***************************************************************************/
|
||||
/*******************External Event Handling in WORKING**********************/
|
||||
/***************************************************************************/
|
||||
void SingleFillHedger::_transform_to_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
|
||||
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::_handle_events_in_WORKING(const EventData& event_data)
|
||||
{
|
||||
if (event_data.external_event == ExternalHedgerEvents::OrderState)
|
||||
{
|
||||
const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state);
|
||||
if (update_message.terminal_status())
|
||||
transform_to_END();
|
||||
else if (update_message.has_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);
|
||||
// TODO
|
||||
//_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;
|
||||
// TODO
|
||||
//_spreader_manager.cancel_order(_order_key);
|
||||
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::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data)
|
||||
void SingleFillHedger::transform_to_END()
|
||||
{
|
||||
if (event_data.external_event == ExternalHedgerEvents::OrderState)
|
||||
{
|
||||
const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state);
|
||||
if (update_message.terminal_status())
|
||||
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);
|
||||
}
|
||||
/***************************************************************************/
|
||||
/*********************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);
|
||||
}
|
||||
|
||||
void SingleFillHedger::on_time (const bts::TimeStamp&)
|
||||
{}
|
||||
|
||||
}}
|
||||
@@ -5,9 +5,14 @@
|
||||
#include "lib/api/services/OrderService.pb.h"
|
||||
#include "lib/utils/bts_chrono.h"
|
||||
#include "server/sparkd/orderman/utils/orderman_utils.h"
|
||||
#include "server/sparkd/spreader/hedger/HedgePriceQuantityState.h"
|
||||
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h"
|
||||
|
||||
namespace bts {
|
||||
namespace orderman {
|
||||
@@ -16,137 +21,29 @@ class LegPropertyData;
|
||||
class SpreaderOrderUpdateMessage;
|
||||
class SingleFillHedger
|
||||
{
|
||||
enum class ExternalHedgerEvents
|
||||
{
|
||||
// order status update (or fills)
|
||||
OrderState,
|
||||
Timer,
|
||||
// market data update from the exchange
|
||||
MDUpdate,
|
||||
// user modification of the hedger price
|
||||
UserHedgePriceChange,
|
||||
// cancel of this hedge order
|
||||
HedgeCancel,
|
||||
};
|
||||
|
||||
enum class HedgerState
|
||||
{
|
||||
START,
|
||||
WAITING_FOR_FIRST_ACK,
|
||||
WAITING_FOR_FIRST_ACK_CANCELLED,
|
||||
WORKING,
|
||||
WAITING_FOR_CANCEL_ACK,
|
||||
END
|
||||
};
|
||||
|
||||
class EventData
|
||||
{
|
||||
public:
|
||||
const ExternalHedgerEvents external_event;
|
||||
const SpreaderOrderUpdateMessage* order_state;
|
||||
const Price hedge_price;
|
||||
|
||||
EventData(const SpreaderOrderUpdateMessage* order_state_arg)
|
||||
:
|
||||
external_event(ExternalHedgerEvents::OrderState),
|
||||
order_state(order_state_arg),
|
||||
hedge_price(0.0)
|
||||
{}
|
||||
EventData(Price hedge_price_arg)
|
||||
:
|
||||
external_event(ExternalHedgerEvents::UserHedgePriceChange),
|
||||
order_state(NULL),
|
||||
hedge_price(hedge_price_arg)
|
||||
{}
|
||||
EventData(ExternalHedgerEvents external_event_arg)
|
||||
:
|
||||
external_event(external_event_arg),
|
||||
order_state(NULL),
|
||||
hedge_price(0.0)
|
||||
{}
|
||||
private:
|
||||
EventData()
|
||||
:
|
||||
external_event(ExternalHedgerEvents::Timer),
|
||||
order_state(NULL),
|
||||
hedge_price(0.0)
|
||||
{}
|
||||
};
|
||||
|
||||
// price and quantity state for the hedger is kept here
|
||||
class HedgePriceQuantityState
|
||||
{
|
||||
private:
|
||||
// price at which to get the fill. this could
|
||||
// be modifie dby the user
|
||||
Price _target_price;
|
||||
// this can never be modified
|
||||
const Quantity _target_quantity;
|
||||
const api::Side _side;
|
||||
// filled part of the order, updated as fills
|
||||
// come in
|
||||
Quantity _aggregated_filled_quantity;
|
||||
// the price of the "active" hedger order
|
||||
Price _out_price;
|
||||
public:
|
||||
HedgePriceQuantityState(Price target_price, Quantity target_quantity, api::Side target_side)
|
||||
:
|
||||
_target_price(target_price),
|
||||
_target_quantity(target_quantity),
|
||||
_side (target_side),
|
||||
_aggregated_filled_quantity(0)
|
||||
{
|
||||
}
|
||||
// called when the user updates a working hedge order price
|
||||
void udpate_target_price(Price new_target_price) { _target_price = new_target_price; }
|
||||
// called as the hedge order gets filled
|
||||
void update_fill(Quantity fill_quantity)
|
||||
{
|
||||
_aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + fill_quantity.value());
|
||||
}
|
||||
// the hedger forgets everything and goes to the end state
|
||||
Price target_price() const { return _target_price; }
|
||||
Quantity target_quantity() const { return _target_quantity; }
|
||||
Quantity aggregated_filled_quantity() const { return _aggregated_filled_quantity; }
|
||||
// tells if the out_price and target_price are in sync
|
||||
api::Side side() const { return _side; }
|
||||
// this is the order quantity net of the fills
|
||||
Quantity remaining_to_fill() const
|
||||
{
|
||||
uint32_t rv = _aggregated_filled_quantity.value() >= _target_quantity.value() ? 0 : _target_quantity.value() - _aggregated_filled_quantity.value();
|
||||
return Quantity(rv);
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
// ISpreaderManager& _spreader_manager;
|
||||
// const LegPropertyData& _leg_property_data;
|
||||
bts::orderman::SpreaderOrderBase::ChildOrder _order;
|
||||
HedgePriceQuantityState _price_quantity_state;
|
||||
HedgerState _state;
|
||||
IHedgerStateWorker* _curr_state_worker;
|
||||
HedgerStartStateWorker _start_state_worker;
|
||||
HedgerWaitingForFirstAckStateWorker _waiting_for_first_ack_state_worker;
|
||||
HedgerWaitingForFirstAckCancelledStateWorker _waiting_for_first_ack_cancelled_state_worker;
|
||||
HedgerWorkingStateWorker _working_state_worker;
|
||||
HedgerWaitingForCancelAckStateWorker _waiting_for_cancel_ack_state_worker;
|
||||
HedgerEndStateWorker _end_state_worker;
|
||||
private:
|
||||
/********************External Event Handling in START***********************/
|
||||
void _handle_events_in_START(const EventData& event_data);
|
||||
/*********External Event Handling in WAITING_FOR_FIRST_ACK******************/
|
||||
private:
|
||||
void transform_to_START();
|
||||
void transform_to_WAITING_FOR_FIRST_ACK();
|
||||
void _handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data);
|
||||
/*******************External Event Handling in WORKING**********************/
|
||||
void _transform_to_WORKING();
|
||||
void _handle_events_in_WORKING(const EventData& event_data);
|
||||
/*********External Event Handling in WAITING_FOR_CANCEL_ACK******************/
|
||||
void transform_to_WAITING_FOR_FIRST_ACK_CANCELLED ();
|
||||
void transform_to_WORKING();
|
||||
void transform_to_WAITING_FOR_CANCEL_ACK();
|
||||
void _handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data);
|
||||
/*********************External Event Handling in END*************************/
|
||||
void transform_to_END();
|
||||
void _handle_events_in_END(const EventData& event_data);
|
||||
|
||||
void _fire_event(const EventData& event_data);
|
||||
public:
|
||||
SingleFillHedger(ISpreaderManager& spreader_manager,
|
||||
const LegPropertyData& leg_property_data,
|
||||
bts::orderman::SpreaderOrderBase::ChildOrder child_order,
|
||||
bts::orderman::SpreaderOrderBase::ChildOrder order,
|
||||
bts::Price hedge_price,
|
||||
bts::Quantity hedge_quantity,
|
||||
api::Side hedge_side);
|
||||
@@ -157,9 +54,9 @@ public:
|
||||
// it will never come back
|
||||
bool is_terminal_state () const;
|
||||
// true if the hedger can accept a price change
|
||||
bool accepting_price_change();
|
||||
bool accepting_price_change() const;
|
||||
// this is the order quantity net of the fills (qty - filled_qty)
|
||||
Quantity remaining_to_fill();
|
||||
Quantity remaining_to_fill() const;
|
||||
// hedger does not do anything until this
|
||||
void init();
|
||||
// called by the spreader when there is an order update
|
||||
@@ -173,8 +70,15 @@ public:
|
||||
void cancel_hedge();
|
||||
// immediatly terminates this hedger, without any attempts
|
||||
// to cancel the order
|
||||
void terminate () { transform_to_END (); }
|
||||
void terminate ();
|
||||
// on the engine infrastructure time
|
||||
void on_time(const bts::TimeStamp&);
|
||||
friend HedgerStartStateWorker;
|
||||
friend HedgerWaitingForFirstAckStateWorker;
|
||||
friend HedgerWaitingForFirstAckCancelledStateWorker;
|
||||
friend HedgerWorkingStateWorker;
|
||||
friend HedgerWaitingForCancelAckStateWorker;
|
||||
friend HedgerEndStateWorker;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
#include "server/sparkd/orderman/utils/orderman_utils.h"
|
||||
#include "lib/api/services/OrderService.pb.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
// price and quantity state for the hedger is kept here
|
||||
class HedgePriceQuantityState
|
||||
{
|
||||
private:
|
||||
// these const's are the price, qty and
|
||||
// side of the hedger order
|
||||
const Price _target_price;
|
||||
const Quantity _target_quantity;
|
||||
const api::Side _side;
|
||||
// filled part of the order, updated as fills come in
|
||||
Quantity _aggregated_filled_quantity;
|
||||
// the price of the "active" hedger order
|
||||
Price _out_price;
|
||||
public:
|
||||
HedgePriceQuantityState(Price target_price, Quantity target_quantity, api::Side target_side)
|
||||
:
|
||||
_target_price(target_price),
|
||||
_target_quantity(target_quantity),
|
||||
_side (target_side),
|
||||
_aggregated_filled_quantity(0),
|
||||
_out_price (_target_price)
|
||||
{
|
||||
}
|
||||
// called as the hedge order gets filled
|
||||
void update_fill(Quantity fill_quantity)
|
||||
{
|
||||
_aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + fill_quantity.value());
|
||||
}
|
||||
Price target_price() const { return _target_price; }
|
||||
Quantity target_quantity() const { return _target_quantity; }
|
||||
api::Side side() const { return _side; }
|
||||
Quantity aggregated_filled_quantity() const { return _aggregated_filled_quantity; }
|
||||
Price out_price () const {return _out_price;}
|
||||
// this is the order quantity net of the fills
|
||||
Quantity remaining_to_fill() const
|
||||
{
|
||||
uint32_t rv = _aggregated_filled_quantity.value() >= _target_quantity.value() ? 0 : _target_quantity.value() - _aggregated_filled_quantity.value();
|
||||
return Quantity(rv);
|
||||
}
|
||||
};
|
||||
}}
|
||||
@@ -2,14 +2,17 @@
|
||||
|
||||
#include "server/sparkd/orderman/utils/orderman_utils.h"
|
||||
#include "lib/utils/bts_chrono.h"
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerState.h"
|
||||
|
||||
namespace bts {
|
||||
namespace orderman {
|
||||
class SpreaderOrderUpdateMessage;
|
||||
class Book;
|
||||
class SingleFillHedger;
|
||||
class IHedgerStateWorker
|
||||
{
|
||||
public:
|
||||
virtual void build_once (SingleFillHedger* hedger) = 0;
|
||||
// called once and only once, before any other calls.
|
||||
virtual void init () = 0;
|
||||
// called only when this hedger's order is updated
|
||||
@@ -24,5 +27,6 @@ public:
|
||||
virtual void terminate() = 0;
|
||||
// time update from the infrastructure
|
||||
virtual void on_time(const TimeStamp&) = 0;
|
||||
virtual HedgerState state () = 0;
|
||||
};
|
||||
}}
|
||||
@@ -5,8 +5,11 @@
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerEndStateWorker::init()
|
||||
{}
|
||||
{
|
||||
bts_assert_msg (false, "HedgerEndStateWorker::init illegal operation");
|
||||
}
|
||||
void HedgerEndStateWorker::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
void HedgerEndStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
@@ -17,4 +20,5 @@ void HedgerEndStateWorker::terminate()
|
||||
{}
|
||||
void HedgerEndStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
HedgerState HedgerEndStateWorker::state() {return HedgerState::END;}
|
||||
}}
|
||||
@@ -4,15 +4,22 @@
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
class SingleFillHedger;
|
||||
// at some point we should have a CleanEnd and an UncleanEnd, where
|
||||
// in the former we know that the order has reached its terminal state
|
||||
class HedgerEndStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -1,20 +1,40 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h"
|
||||
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
|
||||
#include "server/sparkd/orderman/md/Book.h"
|
||||
#include "server/sparkd/spreader/SingleFillHedger.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerStartStateWorker::init()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key {}, placing order", _hedger->_order.order_key().value());
|
||||
// this is the only place from where the hedger sends the order
|
||||
_hedger->_order.create(bts::orderman::NullTickToTradeCorID, _hedger->_price_quantity_state.out_price(), _hedger->_price_quantity_state.target_quantity());
|
||||
_hedger->transform_to_WAITING_FOR_FIRST_ACK ();
|
||||
}
|
||||
void HedgerStartStateWorker::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
{
|
||||
bts_assert_msg (false, "HedgerStartStateWorker::on_order_update illegal operation");
|
||||
}
|
||||
void HedgerStartStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
{
|
||||
// market data will not be sent until out of start.
|
||||
bts_assert_msg (false, "HedgerStartStateWorker::on_book illegal operation");
|
||||
}
|
||||
void HedgerStartStateWorker::cancel()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerStartStateWorker::cancel order_key {}, going to END state", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerStartStateWorker::terminate()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerStartStateWorker::terminate order_key {}, going to END state", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerStartStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
{
|
||||
}
|
||||
HedgerState HedgerStartStateWorker::state() {return HedgerState::START;}
|
||||
}}
|
||||
@@ -7,12 +7,17 @@ namespace orderman{
|
||||
|
||||
class HedgerStartStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,14 @@
|
||||
#pragma once
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
enum class HedgerState
|
||||
{
|
||||
START,
|
||||
WAITING_FOR_FIRST_ACK,
|
||||
WAITING_FOR_FIRST_ACK_CANCELLED,
|
||||
WORKING,
|
||||
WAITING_FOR_CANCEL_ACK,
|
||||
END
|
||||
};
|
||||
}}
|
||||
+25
-6
@@ -1,18 +1,37 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h"
|
||||
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
|
||||
#include "server/sparkd/spreader/SingleFillHedger.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerWaitingForCancelAckStateWorker::init()
|
||||
{}
|
||||
void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
{
|
||||
bts_assert_msg (false, "HedgerWaitingForCancelAckStateWorker::init illegal operation");
|
||||
}
|
||||
void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update)
|
||||
{
|
||||
bts_assert (order_update.acknowledged());
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity());
|
||||
if (order_update.terminal_status())
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWaitingForCancelAckStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
void HedgerWaitingForCancelAckStateWorker::cancel()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::cancel order_key {}, already waiting for cancel", _hedger->_order.order_key().value());
|
||||
}
|
||||
void HedgerWaitingForCancelAckStateWorker::terminate()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::terminate order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWaitingForCancelAckStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
{
|
||||
// TODO: timeout
|
||||
}
|
||||
HedgerState HedgerWaitingForCancelAckStateWorker::state() {return HedgerState::WAITING_FOR_CANCEL_ACK;}
|
||||
}}
|
||||
@@ -7,12 +7,17 @@ namespace orderman{
|
||||
|
||||
class HedgerWaitingForCancelAckStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -1,18 +0,0 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWaitingForFirstAck::init()
|
||||
{}
|
||||
void HedgerWaitingForFirstAck::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAck::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAck::cancel()
|
||||
{}
|
||||
void HedgerWaitingForFirstAck::terminate()
|
||||
{}
|
||||
void HedgerWaitingForFirstAck::on_time(const TimeStamp&)
|
||||
{}
|
||||
}}
|
||||
@@ -1,18 +0,0 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWaitingForFirstAckCancelled::init()
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelled::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelled::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelled::cancel()
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelled::terminate()
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelled::on_time(const TimeStamp&)
|
||||
{}
|
||||
}}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h"
|
||||
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
|
||||
#include "server/sparkd/spreader/SingleFillHedger.h"
|
||||
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::init()
|
||||
{
|
||||
bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init illegal operation");
|
||||
}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update)
|
||||
{
|
||||
bts_assert (order_update.acknowledged());
|
||||
_hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity());
|
||||
if (order_update.terminal_status())
|
||||
_hedger->transform_to_END ();
|
||||
else
|
||||
{
|
||||
// this means the first ack is here and we should
|
||||
// be able to cancel it now
|
||||
_hedger->_order.cancel();
|
||||
_hedger->transform_to_WAITING_FOR_CANCEL_ACK ();
|
||||
}
|
||||
}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::cancel()
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForFirstAckCancelledStateWorker::cancel order_key {}, already cancelled", _hedger->_order.order_key().value());
|
||||
// already been cancelled
|
||||
}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::terminate()
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForFirstAckCancelledStateWorker::terminate order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWaitingForFirstAckCancelledStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
HedgerState HedgerWaitingForFirstAckCancelledStateWorker::state() {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;}
|
||||
}}
|
||||
+6
-1
@@ -5,14 +5,19 @@
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
class HedgerWaitingForFirstAckCancelled : public IHedgerStateWorker
|
||||
class HedgerWaitingForFirstAckCancelledStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h"
|
||||
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
|
||||
#include "server/sparkd/spreader/SingleFillHedger.h"
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWaitingForFirstAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerWaitingForFirstAckStateWorker::init()
|
||||
{
|
||||
bts_assert_msg (false, "HedgerWaitingForFirstAckStateWorker::init illegal operation");
|
||||
}
|
||||
void HedgerWaitingForFirstAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update)
|
||||
{
|
||||
bts_assert (order_update.acknowledged());
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity());
|
||||
if (order_update.terminal_status())
|
||||
_hedger->transform_to_END ();
|
||||
else
|
||||
// this means the first ack
|
||||
_hedger->transform_to_WORKING ();
|
||||
}
|
||||
void HedgerWaitingForFirstAckStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
void HedgerWaitingForFirstAckStateWorker::cancel()
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::cancel order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_WAITING_FOR_FIRST_ACK_CANCELLED ();
|
||||
}
|
||||
void HedgerWaitingForFirstAckStateWorker::terminate()
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::terminate order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWaitingForFirstAckStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
HedgerState HedgerWaitingForFirstAckStateWorker::state() {return HedgerState::WAITING_FOR_FIRST_ACK;}
|
||||
}}
|
||||
+6
-1
@@ -5,14 +5,19 @@
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
class HedgerWaitingForFirstAck : public IHedgerStateWorker
|
||||
class HedgerWaitingForFirstAckStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -1,18 +1,40 @@
|
||||
#include "server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h"
|
||||
|
||||
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
|
||||
#include "server/sparkd/spreader/SingleFillHedger.h"
|
||||
namespace bts{
|
||||
namespace orderman{
|
||||
|
||||
void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
|
||||
void HedgerWorkingStateWorker::init()
|
||||
{}
|
||||
void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage&)
|
||||
{}
|
||||
{
|
||||
bts_assert_msg (false, "HedgerWorkingStateWorker::init illegal operation");
|
||||
}
|
||||
void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update)
|
||||
{
|
||||
bts_assert (order_update.acknowledged());
|
||||
LOG(OrderMan, Diag, "HedgerWorkingStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity());
|
||||
if (order_update.terminal_status())
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&)
|
||||
{}
|
||||
{
|
||||
/// TODO:post hedging
|
||||
}
|
||||
void HedgerWorkingStateWorker::cancel()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWorkingStateWorker::cancel order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->_order.cancel();
|
||||
_hedger->transform_to_WAITING_FOR_CANCEL_ACK ();
|
||||
}
|
||||
void HedgerWorkingStateWorker::terminate()
|
||||
{}
|
||||
{
|
||||
LOG(OrderMan, Diag, "HedgerWorkingStateWorker::terminate order_key {}", _hedger->_order.order_key().value());
|
||||
_hedger->transform_to_END ();
|
||||
}
|
||||
void HedgerWorkingStateWorker::on_time(const TimeStamp&)
|
||||
{}
|
||||
{
|
||||
/// TODO:post hedging
|
||||
}
|
||||
HedgerState HedgerWorkingStateWorker::state() {return HedgerState::WORKING;}
|
||||
}}
|
||||
@@ -7,12 +7,17 @@ namespace orderman{
|
||||
|
||||
class HedgerWorkingStateWorker : public IHedgerStateWorker
|
||||
{
|
||||
private:
|
||||
SingleFillHedger* _hedger;
|
||||
public:
|
||||
void build_once (SingleFillHedger* hedger) override;
|
||||
void init () override;
|
||||
void on_order_update (const SpreaderOrderUpdateMessage& order_update) override;
|
||||
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
|
||||
void cancel() override;
|
||||
void terminate() override;
|
||||
void on_time(const TimeStamp&) override;
|
||||
HedgerState state () override;
|
||||
};
|
||||
|
||||
}}
|
||||
Reference in new issue
Block a user