removed the init call from Hedger

This commit is contained in:
Taha Afzal committed 2018-12-14 17:50:44 -05:00
1 parent 8894aea1ad
commit 175204efdf
19 files changed
+20 -81

No files matched your search

@@ -293,7 +293,7 @@ bool SpreaderOrder::_all_hedger_orders_in_terminal_state(){
SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx);
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++){
SingleFillHedger& hedger = leg_data.get_hedger(h_idx);
if (!hedger.is_terminal_state())
if (hedger.is_active_order())
return false;
}
}
@@ -109,10 +109,6 @@ _end_state_worker (this, other._end_state_worker){
/********************************************************************/
/****************************External Calls**************************/
/********************************************************************/
void SingleFillHedger::init(){
LOG(OrderMan, Diag, "SingleFillHedger::init key: {}", _key().value());
_worker->init();
}
void SingleFillHedger::init (Price price,
Quantity quantity,
ChildOrder& child_order){
@@ -143,6 +139,11 @@ void SingleFillHedger::terminate (){
void SingleFillHedger::on_time (const bts::TimeStamp& ts){
_worker->on_time (ts);
}
bool SingleFillHedger::is_active_order () const {
bool no_active_order = _worker->state() == HedgerState::START ||
_worker->state() == HedgerState::END;
return !no_active_order;
}
bool SingleFillHedger::is_terminal_state () const {
return _worker->state() == HedgerState::END;
}
@@ -83,10 +83,6 @@ public:
SingleFillHedger (SingleFillHedger&&);
SingleFillHedger& operator=(const SingleFillHedger&) = delete;
SingleFillHedger& operator=(SingleFillHedger&&) = delete;
// the a-f actions are associated with the state machine
// side effect actions
//a. leave the start state and submit the order
void init();
//a. leave the start state and submit the order
void init (Price price, Quantity quantity, ChildOrder& child_order);
//b. called by the spreader when there is an order update
@@ -103,7 +99,11 @@ public:
void terminate ();
//f. on the engine infrastructure time
void on_time(const bts::TimeStamp&);
// returns true if the quoter is in the final state, from which
// true if the hedger has an active working order. the order can
// be in an unknown state, but as long as an order has been sent
// and it has not reached a terminal state, its considered "active"
bool is_active_order() const;
// returns true if the hedger is in the final state, from which
// it will never come back
bool is_terminal_state () const;
// true if the hedger can accept a price change
@@ -22,7 +22,6 @@ _reported_state(){
_hedger_order_builders.reserve(_n_legs);
_quoter_child_order_states.reserve(_n_legs);
_quoters.reserve(_n_legs);
//_hedgers.reserve(_n_legs);
_h_managers.reserve(_n_legs);
_unhedged_deltas.reserve(_n_legs);
_leg_data.reserve(_n_legs);
@@ -35,7 +34,6 @@ _reported_state(){
ChildOrder empty_order;
_quoter_child_order_states.emplace_back (empty_order,leg_property_data.leg_security_key(),_is_live,true);
_quoters.emplace_back(spreader_manager, leg_property_data, _n_legs, _quoter_child_order_states.back());
//_hedgers.emplace_back ();
_h_managers.emplace_back(spreader_manager,leg_property_data,_is_live),
_unhedged_deltas.emplace_back();
_leg_data.emplace_back(leg_property_data,
@@ -93,30 +91,6 @@ SingleFillHedger& SpreaderBookkeepingData::add_new_hedger(ISpreaderManager&,
ChildOrder hedge_order = leg_data.hedger_order_builder().build();
SingleFillHedger& rv = l_hm.get_hedger();
rv.init (hedge_price,hedge_quantity,hedge_order);
return rv;
// if (serv)
// serv->log(trace, "SpreaderBookkeepingData::add_new_hedger");
// LOG(OrderMan, Info, "SpreaderBookkeepingData::add_new_hedger "
// "leg_index:{} price:{} quantity:{} cid:{}",
// leg_index, hedge_price, hedge_quantity,trace.sn);
// bts_assert(leg_index < _n_legs);
// SpreaderLegData& leg_data = _leg_data[leg_index];
// std::vector<SingleFillHedger>& leg_hedgers = _hedgers[leg_index];
// if (serv)
// serv->log(trace, "SpreaderBookkeepingData::add_new_hedger:1");
// bts::orderman::ChildOrder hedge_order = leg_data.hedger_order_builder().build();
// if (serv)
// serv->log(trace, "SpreaderBookkeepingData::add_new_hedger:2");
// leg_hedgers.emplace_back (spreader_manager,
// leg_data.leg_property_data(),
// hedge_order,
// hedge_price,
// hedge_quantity,
// trace,
// _is_live);
// if (serv)
// serv->log(trace, "SpreaderBookkeepingData::add_new_hedger:3");
// return leg_hedgers.back();
return rv;
}
}}
}}
@@ -33,7 +33,6 @@ private:
std::vector<SpreaderOrderBuilder> _hedger_order_builders;
std::vector<SpreaderChildOrderState> _quoter_child_order_states;
std::vector<SingleLegQuoter> _quoters;
//std::vector<std::vector<SingleFillHedger>> _hedgers;
std::vector<HedgerManager> _h_managers;
std::vector<UnhedgedDelta> _unhedged_deltas;
std::vector<SpreaderLegData> _leg_data;
@@ -21,8 +21,6 @@ public:
// string representation of the state
virtual const std::string state_text () const = 0;
// called once and only once, before any other calls.
virtual void init () = 0;
// called once and only once, before any other calls.
virtual void init (Price price,
Quantity quantity,
ChildOrder& child_order) = 0;
@@ -4,9 +4,6 @@
namespace bts{
namespace orderman{
void HedgerEndStateWorker::init(){
bts_assert_msg (false, "HedgerEndStateWorker::init illegal operation");
}
void HedgerEndStateWorker::init (Price,
Quantity,
ChildOrder&){
@@ -15,7 +15,6 @@ public:
void on_transition () override {}
HedgerState state () const override {return HedgerState::END;}
const std::string state_text () const override {return "END";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -6,15 +6,6 @@
namespace bts{
namespace orderman{
void HedgerStartStateWorker::init(){
LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key: {}, placing order price: {} quantity: {}",
_hedger->_key().value(), _hedger->_price_quantity_state.out_price().value(), _hedger->_price_quantity_state.target_quantity().value());
// this is the only place from where the hedger sends the order
_hedger->_price_quantity_state.update_out_price_quantity (_hedger->_price_quantity_state.target_price(), _hedger->_price_quantity_state.target_quantity());
_hedger->_place_order (_hedger->_price_quantity_state.out_price(),
_hedger->_price_quantity_state.out_quantity());
_hedger->transform_to_WAITING_FOR_FIRST_ACK ();
}
void HedgerStartStateWorker::init (Price price,
Quantity quantity,
ChildOrder& child_order){
@@ -19,7 +19,6 @@ public:
void on_transition () override {}
HedgerState state () const override {return HedgerState::START;}
const std::string state_text () const override {return "START";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -5,13 +5,11 @@
namespace bts{
namespace orderman{
void HedgerWaitingForCancelAckStateWorker::init(){
bts_assert_msg (false, "HedgerWaitingForCancelAckStateWorker::init illegal operation");
}
void HedgerWaitingForCancelAckStateWorker::init (Price,
Quantity,
ChildOrder&){
bts_assert_msg (false, "HedgerWaitingForCancelAckStateWorker::init illegal operation");
bts_assert_msg (false, "HedgerWaitingForCancelAckStateWorker::init "
"illegal operation");
}
void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderChildOrderState& order_update){
bts_assert (order_update.acknowledged());
@@ -19,7 +19,6 @@ public:
void on_transition () override {}
HedgerState state () const override {return HedgerState::WAITING_FOR_CANCEL_ACK;}
const std::string state_text () const override {return "WAITING_FOR_CANCEL_ACK";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -6,14 +6,12 @@
namespace bts{
namespace orderman{
void HedgerWaitingForFirstAckCancelledStateWorker::init(){
bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init illegal operation");
}
void HedgerWaitingForFirstAckCancelledStateWorker::init(
Price,
Quantity,
ChildOrder&){
bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init illegal operation");
bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init "
"illegal operation");
}
void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderChildOrderState& order_update){
bts_assert (order_update.acknowledged());
@@ -19,7 +19,6 @@ public:
void on_transition () override {}
HedgerState state () const override {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;}
const std::string state_text () const override {return "WAITING_FOR_FIRST_ACK_CANCELLED";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -4,13 +4,11 @@
namespace bts{
namespace orderman{
void HedgerWaitingForFirstAckStateWorker::init(){
bts_assert_msg (false, "HedgerWaitingForFirstAckStateWorker::init illegal operation");
}
void HedgerWaitingForFirstAckStateWorker::init (Price,
Quantity,
ChildOrder&){
bts_assert_msg (false, "HedgerWaitingForFirstAckStateWorker::init illegal operation");
bts_assert_msg (false, "HedgerWaitingForFirstAckStateWorker::init "
"illegal operation");
}
void HedgerWaitingForFirstAckStateWorker::on_order_update(const SpreaderChildOrderState& order_update){
bts_assert (order_update.acknowledged());
@@ -19,7 +19,6 @@ public:
void on_transition () override {}
HedgerState state () const override {return HedgerState::WAITING_FOR_FIRST_ACK;}
const std::string state_text () const override {return "WAITING_FOR_FIRST_ACK";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -9,9 +9,6 @@ namespace orderman{
void HedgerWorkingStateWorker::on_transition(){
_order_touch_time = _hedger->_current_time();
}
void HedgerWorkingStateWorker::init(){
bts_assert_msg (false, "HedgerWorkingStateWorker::init illegal operation");
}
void HedgerWorkingStateWorker::init(Price,
Quantity,
ChildOrder&){
@@ -23,7 +23,6 @@ public:
void on_transition () override;
HedgerState state () const override {return HedgerState::WORKING;}
const std::string state_text () const override {return "WORKING";}
void init () override;
void init (Price price,Quantity quantity,ChildOrder& child_order) override;
void on_order_update (const SpreaderChildOrderState& order_update) override;
void on_book (const bts::orderman::Book& book,trace::CorID &) override;
@@ -1260,8 +1260,7 @@ TEST_CASE ("hedger_START_state", "[spreader]")
LOG(OrderMan, Diag, "hedger_START_state.transition_to_start");
}
SECTION("1. init")
{
hedger.init ();
{
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity);
LOG(OrderMan, Diag, "hedger_START_state.init");
}
@@ -1305,7 +1304,6 @@ TEST_CASE ("hedger_WAITING_FOR_FIRST_ACK_state", "[spreader]")
trace::CorID());
verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity);
hedger.init ();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity);
SECTION("1. init")
{
@@ -1365,7 +1363,6 @@ TEST_CASE ("hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state", "[spreader]")
trace::CorID());
verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity);
hedger.init ();
hedger.cancel_hedge();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity);
@@ -1427,7 +1424,6 @@ TEST_CASE ("hedger_WAITING_FOR_CANCEL_ACK_state", "[spreader]")
trace::CorID());
verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity);
hedger.init ();
hedger.cancel_hedge();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity);
@@ -1500,7 +1496,6 @@ TEST_CASE ("hedger_END_state", "[spreader]")
trace::CorID());
verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity);
hedger.init ();
SpreaderChildOrderState& u1 = hedger.order_state();
on_order_update (u1, api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
hedger.on_order_update (u1);
@@ -1559,7 +1554,6 @@ TEST_CASE ("hedger_WORKING", "[spreader]")
verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity);
SpreaderChildOrderState& u = hedger.order_state();
hedger.init ();
on_order_update (u, api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
hedger.on_order_update (u);
verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20));