From d1861cb404cf3f4ad7a16fbe5437ee976d37c6ed Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 3 Jan 2018 15:00:08 -0500 Subject: [PATCH] SPARK-327 (restrcutured SpreaderBookkeepingData to be more efficent) --- .../spreader_orders/SpreaderOrder.cpp | 17 +- ...SpreaderWaitingForCancelAllStateWorker.cpp | 4 +- ...SpreaderWaitingForFirstConnStateWorker.cpp | 15 +- .../SpreaderWorkingStateWorker.cpp | 18 +- .../sparkd/orderman/tests/spreader_tests.cpp | 352 +++++++++--------- .../sparkd/spreader/SingleFillHedger.cpp | 50 ++- src/server/sparkd/spreader/SingleFillHedger.h | 2 +- .../sparkd/spreader/SingleLegQuoter.cpp | 15 + src/server/sparkd/spreader/SingleLegQuoter.h | 11 +- .../sparkd/spreader/SpreaderBookkeepingData.h | 46 ++- .../sparkd/spreader/SpreaderHedgerData.h | 16 +- src/server/sparkd/spreader/SpreaderLegData.h | 65 ++-- .../spreader/hedger/IHedgerStateWorker.h | 7 +- .../hedger_states/HedgerEndStateWorker.cpp | 2 - .../hedger_states/HedgerEndStateWorker.h | 16 +- .../hedger_states/HedgerStartStateWorker.cpp | 2 - .../hedger_states/HedgerStartStateWorker.h | 14 +- .../HedgerWaitingForCancelAckStateWorker.cpp | 2 - .../HedgerWaitingForCancelAckStateWorker.h | 14 +- ...WaitingForFirstAckCancelledStateWorker.cpp | 2 - ...erWaitingForFirstAckCancelledStateWorker.h | 13 +- .../HedgerWaitingForFirstAckStateWorker.cpp | 2 - .../HedgerWaitingForFirstAckStateWorker.h | 15 +- .../HedgerWorkingStateWorker.cpp | 6 - .../hedger_states/HedgerWorkingStateWorker.h | 14 +- 25 files changed, 409 insertions(+), 311 deletions(-) diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index 4569a51f9..7579c158f 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -20,7 +20,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db, _active(false), _real_orders (!bts::utils::internal::is_unittest_environment()), _create_order_request (api::orderman::CreateOrderRequest()), - //_bookkeeping_data_ptr (nullptr), + _bookkeeping_data_val (0, Price(0), Quantity(0)), _state_worker(nullptr) { LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() ); @@ -35,8 +35,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db, _active (true), _real_orders (!bts::utils::internal::is_unittest_environment()), _create_order_request (cor), - _bookkeeping_data_val (SpreaderBookkeepingData (std::vector(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))), - //_bookkeeping_data_ptr (new SpreaderBookkeepingData (std::vector(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))), + _bookkeeping_data_val (cor.spreader().execution_strategy().leg_params_map().size(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity())), _state_worker(nullptr) { LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value()); @@ -220,7 +219,7 @@ void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) if (cancel_quotes) { if (leg_data.leg_property_data().is_active_quoting()) - leg_data.quoter()->cancel_order(); + leg_data.quoter().cancel_order(); } if (cancel_hedges) for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) @@ -236,7 +235,7 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state() { SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) - if (!leg_data.quoter()->is_terminal_state()) + if (!leg_data.quoter().is_terminal_state()) return false; } return true; @@ -261,7 +260,7 @@ void SpreaderOrder::_terminate_quoters () for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); - leg_data.quoter()->terminate(); + leg_data.quoter().terminate(); } } void SpreaderOrder::_terminate_hedgers () @@ -282,7 +281,7 @@ bool SpreaderOrder::_quoters_can_accept_modification () { SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) - if (!leg_data.quoter()->accept_modifications()) + if (!leg_data.quoter().accept_modifications()) return false; } return true; @@ -296,7 +295,7 @@ void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Qua _compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index, hedge_price, hedge_quantity); bts::orderman::SpreaderOrderBase::ChildOrder new_hedge_order = _get_new_order (leg_data.leg_property_data(), false); - SpreaderHedgerData& hedger_data = leg_data.add_new_hedger (*this, new_hedge_order, hedge_price, hedge_quantity,leg_data.leg_property_data().trading_side()); + SpreaderHedgerData& hedger_data = _bookkeeping_data_val.add_new_hedger (*this, new_hedge_order, hedge_leg_index, hedge_price, hedge_quantity); hedger_data.hedger().init (); } void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index, @@ -314,7 +313,7 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index, } else { - Price driver_price = hedged_leg_data.quoter()->driver_price(hedge_leg_index); + Price driver_price = hedged_leg_data.quoter().driver_price(hedge_leg_index); SpreaderUtils::compute_hedge_price_size_n_legs (filled_leg_data.leg_property_data(), fill_price, fill_quantity, driver_price, hedged_leg_data.leg_property_data(), hedge_price, hedge_quantity); } diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp index 7cad3c359..a8ee79acc 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp @@ -47,13 +47,13 @@ void SpreaderWaitingForCancelAllStateWorker::on_time(const TimeStamp& ts) void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { leg_data.order_update_message().update (status, filled_quantity, average_price, err_msg); - leg_data.quoter()->update_order_status (leg_data.order_update_message()); + leg_data.quoter().update_order_status (leg_data.order_update_message()); } void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) { leg_data.order_update_message().update (status, filled_quantity, average_price, nullptr); - leg_data.quoter()->update_order_status (leg_data.order_update_message()); + leg_data.quoter().update_order_status (leg_data.order_update_message()); } void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status) { diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 1693a4d08..526bb433b 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -91,7 +91,7 @@ void SpreaderWaitingForFirstConnStateWorker::_init_quoters () { SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(index); if (leg_data.leg_property_data().is_active_quoting()) - leg_data.quoter()->init(); + leg_data.quoter().init(); } } bool SpreaderWaitingForFirstConnStateWorker::_can_resolve_securities () @@ -133,8 +133,6 @@ void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata() } void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quoters() { - std::vector leg_data_vector; - //creating the basic data ISpreaderManager& me_ref = *_spreader; const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader(); spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); @@ -151,15 +149,8 @@ void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quo // ii. setting up the order for this leg bts::orderman::SpreaderOrderBase::ChildOrder child_order = _spreader->_get_new_order (leg_property_data, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); LOG(OrderMan, Diag, "Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); - // iii. setting up the quoter (which needs the quoter and property from i and ii) - SingleLegQuoter* leg_quoter = new SingleLegQuoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); - // iv. finally setting up the full leg_data (which needs the quoter and property from i, ii and iii) - SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); - leg_data_vector.push_back(leg_data); - leg_idx++; + _spreader->_bookkeeping_data_val.add_leg (leg_property_data, child_order, me_ref); + leg_idx++; } - bts_assert(leg_data_vector.size() > 0); - _spreader->_bookkeeping_data_val = SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity())); - //_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity())); } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 1180095f1..ae54d8b37 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -37,7 +37,7 @@ void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOr { SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) - leg_data.quoter()->update_order_price_quantity (price, quantity); + leg_data.quoter().update_order_price_quantity (price, quantity); } } } @@ -52,13 +52,13 @@ void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book) // this is a key->index lookup SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key()); // updating md state (this is the only place where its done) - md_leg.set_book(book); + md_leg.update_book(book); // sending md to all quoters for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); if (d.leg_property_data().is_active_quoting()) - d.quoter()->on_book(cid, md_leg.leg_property_data().leg_index(), book); + d.quoter().on_book(cid, md_leg.leg_property_data().leg_index(), book); } // send md to hedgers hedging this security only for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++) @@ -72,7 +72,7 @@ void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) { - leg_data.quoter()->on_time(ts); + leg_data.quoter().on_time(ts); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) leg_data.get_hedger(h_idx).hedger().on_time (ts); } @@ -82,7 +82,7 @@ void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLe { leg_data.order_update_message().update(status, filled_quantity, average_price, err_msg); // this is because the error message could also have status changes - leg_data.quoter()->update_order_status (leg_data.order_update_message()); + leg_data.quoter().update_order_status (leg_data.order_update_message()); _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } @@ -96,18 +96,18 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg // 5. init the hedger SpreaderChildOrderState& order_update_message = leg_data.order_update_message(); order_update_message.update (status, filled_quantity, average_price, nullptr); - leg_data.quoter()->update_order_status (order_update_message); + leg_data.quoter().update_order_status (order_update_message); if (order_update_message.last_update_filled_quantity().value() > 0) { for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++) { - bts::orderman::SpreaderLegData other_leg_data = _spreader->_bookkeeping_data().get_leg_data (q_idx); + SpreaderLegData& other_leg_data = _spreader->_bookkeeping_data().get_leg_data (q_idx); if (q_idx != leg_data.leg_property_data().leg_index()) { // if it is an actively quoting leg, inform the quoter about it // so it can decrease the proportional size if (other_leg_data.leg_property_data().is_active_quoting()) - other_leg_data.quoter()->update_other_leg_fills(leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_quantity()); + other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_quantity()); // a hedge is sent regardless _spreader->_send_hedge (leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_price(), order_update_message.last_update_filled_quantity(), q_idx); } @@ -117,7 +117,7 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status) { leg_data.order_update_message().update (status); - leg_data.quoter()->update_order_status (leg_data.order_update_message()); + leg_data.quoter().update_order_status (leg_data.order_update_message()); } void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { diff --git a/src/server/sparkd/orderman/tests/spreader_tests.cpp b/src/server/sparkd/orderman/tests/spreader_tests.cpp index 38fb9b77b..8133b9dce 100644 --- a/src/server/sparkd/orderman/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/tests/spreader_tests.cpp @@ -236,81 +236,81 @@ TEST_CASE ("book traversal", "[spreader]") } } //this is how the spreader organizes the data -TEST_CASE ("spreader bookkeeping data", "[spreader]") -{ - // constants - double leg_mult_1 = -1.25, leg_mult_2 = 3.33, leg_mult_3 = -1.75; - std::string symbol_1 = "ES", symbol_2 = "ZN", symbol_3 = "GC"; - uint32_t sec_key_1 = 1111, sec_key_2 = 2222, sec_key_3 = 3333; - double lean_ratio_1 = 1.33, lean_ratio_2 = 5.0, lean_ratio_3 = 2.75; - double price_mult_1 = -2.5, price_mult_2 = 5.0, price_mult_3 = -3.33; - Price spread_price (-0.35); - Quantity spread_quantity (125); - OrderKey order_key_1 (4), order_key_2 (22), order_key_3 (2007); - // leg property data - ContractLeg leg_1, leg_2, leg_3; - fill_future_contract_leg (leg_1, sec_key_1, symbol_1, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_SELL, 1.0, 0.25); - fill_future_contract_leg (leg_2, sec_key_2, symbol_2, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_BUY, 1.0, 0.03125); - fill_future_contract_leg (leg_3, sec_key_3, symbol_3, bts::api::Venue::VENUE_GLBX, 2018, 6, 15, leg_mult_3, api::Side::SIDE_SELL, 1.0, 0.05); - QuoteParams qp_1, qp_2, qp_3; - fill_quote_params(qp_1, lean_ratio_1); - fill_quote_params(qp_2, lean_ratio_2); - fill_quote_params(qp_3, lean_ratio_3); - LegSpreaderParams lsp_1, lsp_2, lsp_3; - fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1); - fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2); - fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3); - LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL); - LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); - LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL); - Book book1, book2, book3; - // SpreaderManager - std::vector legs; - legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3); - std::vector books; - books.push_back (book1);books.push_back (book2);books.push_back (book3); - SpreaderManagerForTest spreader_manager (legs, books); - // quoter - SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); - SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); - SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); - // bookkeeping data - std::vector leg_data_v; - leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, "er_1, order_key_1)); - leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, "er_2, order_key_2)); - leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, "er_3, order_key_3)); - SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity); - SECTION("verify security key access") - { - SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3)); - verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); - SpreaderLegData res_2 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_2)); - verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); - SpreaderLegData res_1 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_1)); - verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); - } - SECTION("verify index access") - { - SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2); - verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); - SpreaderLegData res_2 = bookkeeping_data.get_leg_data (1); - verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); - SpreaderLegData res_1 = bookkeeping_data.get_leg_data (0); - verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); - } - SECTION("verify order key access") - { - SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3); - bts_assert (res_3 != nullptr); - verify_leg_data (*res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); - SpreaderLegData* res_2 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_2); - bts_assert (res_2 != nullptr); - verify_leg_data (*res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); - SpreaderLegData* res_1 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_1); - bts_assert (res_1 != nullptr); - verify_leg_data (*res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); - } -} +// TEST_CASE ("spreader bookkeeping data", "[spreader]") +// { +// // constants +// double leg_mult_1 = -1.25, leg_mult_2 = 3.33, leg_mult_3 = -1.75; +// std::string symbol_1 = "ES", symbol_2 = "ZN", symbol_3 = "GC"; +// uint32_t sec_key_1 = 1111, sec_key_2 = 2222, sec_key_3 = 3333; +// double lean_ratio_1 = 1.33, lean_ratio_2 = 5.0, lean_ratio_3 = 2.75; +// double price_mult_1 = -2.5, price_mult_2 = 5.0, price_mult_3 = -3.33; +// Price spread_price (-0.35); +// Quantity spread_quantity (125); +// OrderKey order_key_1 (4), order_key_2 (22), order_key_3 (2007); +// // leg property data +// ContractLeg leg_1, leg_2, leg_3; +// fill_future_contract_leg (leg_1, sec_key_1, symbol_1, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_SELL, 1.0, 0.25); +// fill_future_contract_leg (leg_2, sec_key_2, symbol_2, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_BUY, 1.0, 0.03125); +// fill_future_contract_leg (leg_3, sec_key_3, symbol_3, bts::api::Venue::VENUE_GLBX, 2018, 6, 15, leg_mult_3, api::Side::SIDE_SELL, 1.0, 0.05); +// QuoteParams qp_1, qp_2, qp_3; +// fill_quote_params(qp_1, lean_ratio_1); +// fill_quote_params(qp_2, lean_ratio_2); +// fill_quote_params(qp_3, lean_ratio_3); +// LegSpreaderParams lsp_1, lsp_2, lsp_3; +// fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1); +// fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2); +// fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3); +// LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL); +// LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); +// LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL); +// Book book1, book2, book3; +// // SpreaderManager +// std::vector legs; +// legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3); +// std::vector books; +// books.push_back (book1);books.push_back (book2);books.push_back (book3); +// SpreaderManagerForTest spreader_manager (legs, books); +// // quoter +// SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); +// SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); +// SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); +// // bookkeeping data +// std::vector leg_data_v; +// leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, "er_1, order_key_1)); +// leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, "er_2, order_key_2)); +// leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, "er_3, order_key_3)); +// SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity); +// SECTION("verify security key access") +// { +// SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3)); +// verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); +// SpreaderLegData res_2 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_2)); +// verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); +// SpreaderLegData res_1 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_1)); +// verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); +// } +// SECTION("verify index access") +// { +// SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2); +// verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); +// SpreaderLegData res_2 = bookkeeping_data.get_leg_data (1); +// verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); +// SpreaderLegData res_1 = bookkeeping_data.get_leg_data (0); +// verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); +// } +// SECTION("verify order key access") +// { +// SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3); +// bts_assert (res_3 != nullptr); +// verify_leg_data (*res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); +// SpreaderLegData* res_2 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_2); +// bts_assert (res_2 != nullptr); +// verify_leg_data (*res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); +// SpreaderLegData* res_1 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_1); +// bts_assert (res_1 != nullptr); +// verify_leg_data (*res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); +// } +// } // quote price and quantity for a 2 legged spread TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") { @@ -1599,28 +1599,28 @@ TEST_CASE ("spreader_WORKING", "[spreader]") // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // send fill on leg 1 (20) spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); // send another fill on leg 1 (10) spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false); // send fill on leg 2 (15) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false); // send another fill on leg 2 (30) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); // send another fill on leg 2 (10) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify the hedgers // leg 1 should have 3 hedgers, for each of the 3 fills for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) @@ -1629,8 +1629,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); bts_assert (leg_data_1.n_hedgers () == 3); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1639,18 +1639,18 @@ TEST_CASE ("spreader_WORKING", "[spreader]") auto generic_validate_quoters = [&](QuoterState quoter_state, bool quoter_cancelled_by_spreader) -> void { - verify_complete_quoter_state (*leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); }; auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void { bts_assert (leg_data_1.n_hedgers () == 3); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); - verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); - verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); - verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); - verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); + verify_complete_hedger_state (leg_data_1.get_hedger(0).hedger(), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); + verify_complete_hedger_state (leg_data_1.get_hedger(1).hedger(), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); + verify_complete_hedger_state (leg_data_1.get_hedger(2).hedger(), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); + verify_complete_hedger_state (leg_data_2.get_hedger(0).hedger(), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); + verify_complete_hedger_state (leg_data_2.get_hedger(1).hedger(), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); }; SECTION("1. init") { @@ -1678,8 +1678,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") api::orderman::UpdateSpreaderOrder u; u.set_price(spreader_price.value()); u.set_quantity (spreader_quantity.value()); spreader.on_update (u); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false); // nothing changes with the hedgers generic_validate_hedgers (HedgerState::WORKING); LOG(OrderMan, Diag, "spreader_WORKING.on_update"); @@ -1724,8 +1724,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") true); spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); generic_validate_hedgers (HedgerState::WORKING); LOG(OrderMan, Diag, "spreader_WORKING.on_book"); // 3. shrink to market to force a size change @@ -1739,8 +1739,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") true); spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); generic_validate_hedgers (HedgerState::WORKING); LOG(OrderMan, Diag, "spreader_WORKING.on_book"); // 4. change the market to force both a price and size change @@ -1752,8 +1752,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") true); spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); generic_validate_hedgers (HedgerState::WORKING); LOG(OrderMan, Diag, "spreader_WORKING.on_book"); // 5. remove the market @@ -1766,8 +1766,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") true); spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); generic_validate_hedgers (HedgerState::WORKING); LOG(OrderMan, Diag, "spreader_WORKING.on_book"); } @@ -1794,8 +1794,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); bts_assert (leg_data_1.n_hedgers () == 4); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1815,8 +1815,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); bts_assert (leg_data_1.n_hedgers () == 4); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1870,8 +1870,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (70), Price (2001), nullptr); bts_assert (leg_data_1.n_hedgers () == 4); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1882,7 +1882,7 @@ TEST_CASE ("spreader_WORKING", "[spreader]") // when all of them are at the end state, the spreader // should also go to end spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // all the quoters are done now spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2002), nullptr); @@ -1948,28 +1948,28 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // send fill on leg 1 (20) spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); // send another fill on leg 1 (10) spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false); // send fill on leg 2 (15) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false); // send another fill on leg 2 (30) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); // send another fill on leg 2 (10) spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify the hedgers // leg 1 should have 3 hedgers, for each of the 3 fills bts_assert (leg_data_1.n_hedgers() == 3); @@ -1993,8 +1993,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); bts_assert (leg_data_1.n_hedgers () == 3); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -2016,7 +2016,7 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") for (size_t i = 0; i < bookkeeping_data.n_legs(); i++) { SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i); - bts_assert (leg_data.quoter()->test_only_func_quoter_state() == QuoterState::END); + bts_assert (leg_data.quoter().test_only_func_quoter_state() == QuoterState::END); // all hedgers should be in the end state for (size_t h = 0; h < leg_data.n_hedgers(); h++) bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END); @@ -2059,8 +2059,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") } int64_t time_since_cxl = ms_diff (std::chrono::system_clock::now(), cancel_timestamp); bts_assert (time_since_cxl >= spreader.test_cancel_timeout()); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -2083,8 +2083,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); bts_assert (leg_data_1.n_hedgers () == 3); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -2099,8 +2099,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); bts_assert (leg_data_1.n_hedgers () == 3); bts_assert (leg_data_2.n_hedgers () == 2); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -2119,8 +2119,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") { // send a fill spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -2140,9 +2140,9 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // send cancel for orders, once all quoters and hedgers // are cancelled, spreader should come to end spreader.on_child_update (leg_data_1.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); + verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); spreader.on_child_update (leg_data_2.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (55), Price (2000), nullptr); - verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false); + verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(0), Quantity (0), Quantity (15)); @@ -2160,43 +2160,43 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") } } -// class Temp -// { -// public: -// int i; -// Temp (int arg_i) : i (arg_i){} -// }; -// TEST_CASE ("ref test", "[spreader]") -// { -// Temp* t_ptr = new Temp (100); -// Temp t_val = *t_ptr; -// t_val.i = 200; -// bts_assert (t_ptr->i == 100); -// bts_assert (t_val.i == 200); -// Temp& t_ref = *t_ptr; -// t_ref.i = 200; -// bts_assert (t_ptr->i == 200); -// bts_assert (t_ref.i == 200); -// t_ptr->i = 300; -// bts_assert (t_ptr->i == 300); -// bts_assert (t_ref.i == 300); -// } -// TEST_CASE ("vector ref test", "[spreader]") -// { -// Temp t_val (0); -// std::vector t_vect; -// t_vect.push_back (t_val); -// t_vect.push_back (t_val); -// t_vect.push_back (t_val); -// Temp& t_ref = t_vect[1]; -// t_ref.i = 100; -// bts_assert (t_vect[1].i == 100); -// for (auto it = t_vect.begin(); it != t_vect.end(); it++) -// { -// Temp& t_it_ref = *it; -// t_it_ref.i = 115; -// } -// bts_assert (t_vect[1].i == 115); -// } +class Temp +{ +public: + int i; + Temp (int arg_i) : i (arg_i){} +}; +TEST_CASE ("ref test", "[spreader]") +{ + Temp* t_ptr = new Temp (100); + Temp t_val = *t_ptr; + t_val.i = 200; + bts_assert (t_ptr->i == 100); + bts_assert (t_val.i == 200); + Temp& t_ref = *t_ptr; + t_ref.i = 200; + bts_assert (t_ptr->i == 200); + bts_assert (t_ref.i == 200); + t_ptr->i = 300; + bts_assert (t_ptr->i == 300); + bts_assert (t_ref.i == 300); +} +TEST_CASE ("vector ref test", "[spreader]") +{ + Temp t_val (0); + std::vector t_vect; + t_vect.push_back (t_val); + t_vect.push_back (t_val); + t_vect.push_back (t_val); + Temp& t_ref = t_vect[1]; + t_ref.i = 100; + bts_assert (t_vect[1].i == 100); + for (auto it = t_vect.begin(); it != t_vect.end(); it++) + { + Temp& t_it_ref = *it; + t_it_ref.i = 115; + } + bts_assert (t_vect[1].i == 115); +} }} diff --git a/src/server/sparkd/spreader/SingleFillHedger.cpp b/src/server/sparkd/spreader/SingleFillHedger.cpp index 61256d51e..eb6112968 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.cpp +++ b/src/server/sparkd/spreader/SingleFillHedger.cpp @@ -20,11 +20,55 @@ SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager, _leg_property_data (leg_property_data), _order (order), _price_quantity_state(hedge_price, hedge_quantity, hedge_side), - _worker (nullptr) -{ + _worker (nullptr), + _start_state_worker (this), + _waiting_for_first_ack_state_worker (this), + _waiting_for_first_ack_cancelled_state_worker (this), + _working_state_worker (this), + _waiting_for_cancel_ack_state_worker (this), + _end_state_worker (this) +{ 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 (); } +SingleFillHedger::SingleFillHedger (const SingleFillHedger& other) +: +_spreader (other._spreader), +_leg_property_data (other._leg_property_data), +_order (other._order), +_price_quantity_state (other._price_quantity_state), +_worker(nullptr), +_start_state_worker (this, other._start_state_worker), +_waiting_for_first_ack_state_worker (this, other._waiting_for_first_ack_state_worker), +_waiting_for_first_ack_cancelled_state_worker (this, other._waiting_for_first_ack_cancelled_state_worker), +_working_state_worker (this, other._working_state_worker), +_waiting_for_cancel_ack_state_worker (this, other._waiting_for_cancel_ack_state_worker), +_end_state_worker (this, other._end_state_worker) +{ + HedgerState state = other._worker->state(); + switch(state) + { + case HedgerState::START: + _worker = &_start_state_worker; + break; + case HedgerState::WAITING_FOR_FIRST_ACK: + _worker = &_waiting_for_first_ack_state_worker; + break; + case HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED: + _worker = &_waiting_for_first_ack_cancelled_state_worker; + break; + case HedgerState::WORKING: + _worker = &_working_state_worker; + break; + case HedgerState::WAITING_FOR_CANCEL_ACK: + _worker = &_waiting_for_cancel_ack_state_worker; + break; + case HedgerState::END: + _worker = &_end_state_worker; + break; + } + bts_assert(_worker!=nullptr); +} /********************************************************************/ /****************************External Calls**************************/ /********************************************************************/ @@ -104,7 +148,7 @@ void SingleFillHedger::_switch_state (IHedgerStateWorker* new_state) { LOG(OrderMan, Diag, "SingleFillHedger::_switch_state key: {}, {} -> {} ", _order.order_key().value(), (_worker == nullptr ? "NULL" : _worker->state_text()), new_state->state_text()); _worker = new_state; - _worker->build_once (this); + _worker->on_transition(); } /********************************************************************/ /******************************Helpers*******************************/ diff --git a/src/server/sparkd/spreader/SingleFillHedger.h b/src/server/sparkd/spreader/SingleFillHedger.h index 4ef6256fd..b17e52aa0 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.h +++ b/src/server/sparkd/spreader/SingleFillHedger.h @@ -57,7 +57,7 @@ public: bts::Price hedge_price, bts::Quantity hedge_quantity, api::Side hedge_side); - ~SingleFillHedger() {} + SingleFillHedger (const SingleFillHedger&); //1. leave the start state and submit the order void init(); //2. called by the spreader when there is an order update diff --git a/src/server/sparkd/spreader/SingleLegQuoter.cpp b/src/server/sparkd/spreader/SingleLegQuoter.cpp index 93bd4954e..b733c4fff 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.cpp +++ b/src/server/sparkd/spreader/SingleLegQuoter.cpp @@ -35,6 +35,21 @@ SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader, } _transform_to_START (); } +SingleLegQuoter::SingleLegQuoter(SingleLegQuoter&& other) +: + _two_legged (other._two_legged), + _spreader(other._spreader), + _this_leg_data (other._this_leg_data), + _n_spreader_legs (other._n_spreader_legs), + _order (other._order), + _drivers_temp_usage(other._drivers_temp_usage), + _drivers_commited (other._drivers_commited), + _price_quantity_state(other._price_quantity_state), + _is_permenantly_cancelled (other._is_permenantly_cancelled), + _worker(nullptr) +{ + bts_assert (false); +} /*********************************************************************************/ /*********************************spreader calls**********************************/ /*********************************************************************************/ diff --git a/src/server/sparkd/spreader/SingleLegQuoter.h b/src/server/sparkd/spreader/SingleLegQuoter.h index 0382cc94e..42f6f29b4 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.h +++ b/src/server/sparkd/spreader/SingleLegQuoter.h @@ -56,10 +56,13 @@ public: bts::Price spread_order_price, bts::Quantity spread_order_quantity, bts::orderman::SpreaderOrderBase::ChildOrder child_order); - - ~SingleLegQuoter() - { - } +public: + SingleLegQuoter() = delete; + SingleLegQuoter (SingleLegQuoter&&); + SingleLegQuoter (const SingleLegQuoter&) = delete; + SingleLegQuoter& operator=(const SingleLegQuoter&) = delete; + SingleLegQuoter& operator=(SingleLegQuoter&&) = delete; +public: //1. leave the start state and actually starts processing // market data void init(); diff --git a/src/server/sparkd/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/spreader/SpreaderBookkeepingData.h index 06c7336a9..6acdd3a36 100644 --- a/src/server/sparkd/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/spreader/SpreaderBookkeepingData.h @@ -12,25 +12,34 @@ class SpreaderHedgerData; class SpreaderBookkeepingData { private: + const size_t _n_legs; std::vector _leg_data; + std::vector _quoters; + std::vector> _hedgers; boost::container::flat_map _sec_key_to_index; Price _price; Quantity _quantity; public: - SpreaderBookkeepingData () - : _leg_data (std::vector()), - _sec_key_to_index (boost::container::flat_map()), - _price (Price(0)), - _quantity (Quantity(0)) - {} - SpreaderBookkeepingData(const std::vector& leg_data, Price price, Quantity quantity) + SpreaderBookkeepingData(size_t n_legs, Price price, Quantity quantity) : - _leg_data (leg_data), + _n_legs (n_legs), _price (price), _quantity (quantity) { - for (auto it = leg_data.begin(); it != leg_data.end(); ++it) - _sec_key_to_index.insert(std::pair(it->leg_property_data().security_key(), it->leg_property_data().leg_index())); + _leg_data.reserve (n_legs); + _quoters.reserve (n_legs); + _hedgers.reserve (n_legs); + } + void add_leg (const LegPropertyData& leg_property_data, + SpreaderOrderBase::ChildOrder child_order, + ISpreaderManager& spreader_manager) + { + _quoters.emplace_back(spreader_manager, leg_property_data, _n_legs, _price, _quantity, child_order); + _hedgers.emplace_back (); + //_hedgers.back().reserve(10); + _leg_data.emplace_back(leg_property_data, _quoters.back(), _hedgers.back (), child_order); + bts_assert (_sec_key_to_index.find(leg_property_data.security_key()) == _sec_key_to_index.end()); + _sec_key_to_index.insert(std::pair(leg_property_data.security_key(), leg_property_data.leg_index())); } SpreaderLegData& get_leg_data (SecurityKey security_key) { @@ -49,7 +58,7 @@ public: return _leg_data[index]; } size_t n_legs() const { return _leg_data.size(); } - SpreaderLegData* find_leg_from_quoter_orderkey(orderman::OrderKey order_key) + SpreaderLegData* find_leg_from_quoter_orderkey(OrderKey order_key) { for (auto q_it = _leg_data.begin(); q_it != _leg_data.end(); q_it++) if (q_it->leg_property_data().is_active_quoting()) @@ -57,7 +66,7 @@ public: return &(*q_it); return nullptr; } - SpreaderHedgerData* find_hedger_from_orderkey(orderman::OrderKey order_key) + SpreaderHedgerData* find_hedger_from_orderkey(OrderKey order_key) { for (auto l_it = _leg_data.begin(); l_it != _leg_data.end(); ++l_it) { @@ -67,6 +76,18 @@ public: } return nullptr; } + SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, + SpreaderOrderBase::ChildOrder order, + size_t leg_index, + bts::Price hedge_price, + bts::Quantity hedge_quantity) + { + bts_assert(leg_index < _n_legs); + SpreaderLegData& leg_data = _leg_data[leg_index]; + std::vector& leg_hedgers = _hedgers[leg_index]; + leg_hedgers.emplace_back (spreader_manager, leg_data.leg_property_data(), order, hedge_price, hedge_quantity); + return leg_hedgers.back(); + } Price price () const {return _price;} Quantity quantity () const {return _quantity;} void update_order (Price price, Quantity quantity) @@ -75,5 +96,4 @@ public: _quantity = quantity; } }; - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SpreaderHedgerData.h b/src/server/sparkd/spreader/SpreaderHedgerData.h index eabdb5c79..f89867d2e 100644 --- a/src/server/sparkd/spreader/SpreaderHedgerData.h +++ b/src/server/sparkd/spreader/SpreaderHedgerData.h @@ -10,17 +10,19 @@ namespace orderman{ class SpreaderHedgerData { private: - SingleFillHedger* const _hedger; + SingleFillHedger _hedger; SpreaderChildOrderState _order_update_message; public: - SpreaderHedgerData(SingleFillHedger* hedger, - SpreaderChildOrderState order_update_message) - : - _hedger (hedger), - _order_update_message (order_update_message) + SpreaderHedgerData (ISpreaderManager& spreader_manager, + const LegPropertyData& leg_property_data, + SpreaderOrderBase::ChildOrder order, + bts::Price hedge_price, + bts::Quantity hedge_quantity) + : _hedger(spreader_manager, leg_property_data, order, hedge_price, hedge_quantity, leg_property_data.trading_side()), + _order_update_message (order.order_key()) { } - SingleFillHedger& hedger () {return *_hedger;} + SingleFillHedger& hedger () {return _hedger;} SpreaderChildOrderState& order_update_message() {return _order_update_message;} }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SpreaderLegData.h b/src/server/sparkd/spreader/SpreaderLegData.h index b30e85830..0036107ae 100644 --- a/src/server/sparkd/spreader/SpreaderLegData.h +++ b/src/server/sparkd/spreader/SpreaderLegData.h @@ -6,6 +6,8 @@ #include "SpreaderChildOrderState.h" #include +using bts::orderman::SpreaderOrderBase; + namespace bts{ namespace orderman{ // all the data for a leg : @@ -21,32 +23,46 @@ class SpreaderLegData { private: const LegPropertyData _leg_property_data; - SingleLegQuoter* const _quoter; - orderman::Book _book; + SingleLegQuoter& _quoter; + std::vector& _hedger_data_vector; SpreaderChildOrderState _order_update_message; - std::vector _hedger_data_vector; -public: - SpreaderLegData(const LegPropertyData& leg_property_data_arg, - SingleLegQuoter* quoter_arg, - orderman::OrderKey order_key) - : - _leg_property_data(leg_property_data_arg), - _quoter (quoter_arg), - _book(), - _order_update_message (SpreaderChildOrderState (order_key)), - _hedger_data_vector() {} + Book _book; +public: + SpreaderLegData (const LegPropertyData& leg_property_data, + SingleLegQuoter& quoter, + std::vector& hedger_data_vector, + SpreaderOrderBase::ChildOrder child_order) + : _leg_property_data (leg_property_data), + _quoter (quoter), + _hedger_data_vector (hedger_data_vector), + _order_update_message (child_order.order_key()), + _book() + {} + SpreaderLegData() = delete; + SpreaderLegData(const SpreaderLegData&) = delete; + SpreaderLegData(SpreaderLegData&& other) + : _leg_property_data (other._leg_property_data), + _quoter (other._quoter), + _hedger_data_vector (other._hedger_data_vector), + _order_update_message (other._order_update_message), + _book() + { + bts_assert (false); + } + SpreaderLegData& operator=(const SpreaderLegData&) = delete; + SpreaderLegData& operator=(SpreaderLegData&&) = delete; // accessors const LegPropertyData& leg_property_data() const {return _leg_property_data;} - SingleLegQuoter* quoter() {return _quoter;} - const orderman::Book& book () const {return _book;} + SingleLegQuoter& quoter() {return _quoter;} + const Book& book () const {return _book;} SpreaderChildOrderState& order_update_message () {return _order_update_message;} - orderman::OrderKey order_key() {return _order_update_message.order_key();} + OrderKey order_key() {return _order_update_message.order_key();} // returns the number of active hedgers size_t n_hedgers() { return _hedger_data_vector.size(); } // returns the hedger at a given index SpreaderHedgerData& get_hedger(size_t index) {return _hedger_data_vector[index];} // returns a hedger from its order_key - SpreaderHedgerData* find_hedger_from_orderkey(orderman::OrderKey order_key) + SpreaderHedgerData* find_hedger_from_orderkey(OrderKey order_key) { for (auto h_it = _hedger_data_vector.begin(); h_it != _hedger_data_vector.end(); ++h_it) if (h_it->order_update_message().order_key() == order_key) @@ -56,19 +72,6 @@ public: std::vector& get_hedgers () {return _hedger_data_vector;} // mutators // called for every book update (copied by value) - void set_book(const orderman::Book& book_arg) {_book = book_arg;} - // adds a new hedger with the given values - SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, - bts::orderman::SpreaderOrderBase::ChildOrder order, - bts::Price hedge_price, - bts::Quantity hedge_quantity, - api::Side hedge_side) - { - SpreaderChildOrderState hedger_order_update (order.order_key()); - SingleFillHedger* hedger = new SingleFillHedger(spreader_manager, _leg_property_data, order, hedge_price, hedge_quantity, hedge_side); - SpreaderHedgerData hedger_data(hedger, hedger_order_update); - _hedger_data_vector.push_back(hedger_data); - return _hedger_data_vector.back(); - } + void update_book(const Book& book_arg) {_book = book_arg;} }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h index 3e70b9acc..821f009a1 100644 --- a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h +++ b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h @@ -10,9 +10,10 @@ class SpreaderChildOrderState; class Book; class SingleFillHedger; class IHedgerStateWorker -{ -public: - virtual void build_once (SingleFillHedger* hedger) = 0; +{ +public: + // called once when transition to this state happens + virtual void on_transition () = 0; // state of this worker virtual HedgerState state () const = 0; // string representation of the state diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp index 54ba771f0..99cf52cf9 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -5,8 +5,6 @@ namespace bts{ namespace orderman{ -HedgerEndStateWorker::HedgerEndStateWorker () : _state_text ("END"){} -void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} HedgerState HedgerEndStateWorker::state() const {return HedgerState::END;} const std::string& HedgerEndStateWorker::state_text() const {return _state_text;} void HedgerEndStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h index f6dcaf544..f85f8e85e 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h @@ -10,11 +10,18 @@ class SingleFillHedger; class HedgerEndStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; public: - HedgerEndStateWorker (); - void build_once (SingleFillHedger* hedger) override; + HedgerEndStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("END") + {} + HedgerEndStateWorker (SingleFillHedger* hedger, const HedgerEndStateWorker&) + : HedgerEndStateWorker (hedger) + { + } + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override; @@ -22,7 +29,6 @@ public: 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; + void on_time(const TimeStamp&) override; }; - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp index 7b4204ac0..5b2508677 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -7,8 +7,6 @@ namespace bts{ namespace orderman{ -HedgerStartStateWorker::HedgerStartStateWorker () : _state_text ("START"){} -void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} HedgerState HedgerStartStateWorker::state() const {return HedgerState::START;} const std::string& HedgerStartStateWorker::state_text() const {return _state_text;} void HedgerStartStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h index daeee4539..6e4838790 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h @@ -8,11 +8,17 @@ namespace orderman{ class HedgerStartStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; public: - HedgerStartStateWorker(); - void build_once (SingleFillHedger* hedger) override; + HedgerStartStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("START") + {} + HedgerStartStateWorker (SingleFillHedger* hedger, const HedgerStartStateWorker&) + : HedgerStartStateWorker (hedger) + {} + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override; @@ -20,7 +26,7 @@ public: 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; + void on_time(const TimeStamp&) override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp index fee492a05..8befe1d20 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -5,8 +5,6 @@ namespace bts{ namespace orderman{ -HedgerWaitingForCancelAckStateWorker::HedgerWaitingForCancelAckStateWorker () : _state_text ("WAITING_FOR_CANCEL_ACK"){} -void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} HedgerState HedgerWaitingForCancelAckStateWorker::state() const {return HedgerState::WAITING_FOR_CANCEL_ACK;} const std::string& HedgerWaitingForCancelAckStateWorker::state_text() const {return _state_text;} void HedgerWaitingForCancelAckStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h index c651067fb..b4ccb735e 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h @@ -8,11 +8,18 @@ namespace orderman{ class HedgerWaitingForCancelAckStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; public: - HedgerWaitingForCancelAckStateWorker (); - void build_once (SingleFillHedger* hedger) override; + HedgerWaitingForCancelAckStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("WAITING_FOR_CANCEL_ACK") + {} + HedgerWaitingForCancelAckStateWorker (SingleFillHedger* hedger, const HedgerWaitingForCancelAckStateWorker&) + : HedgerWaitingForCancelAckStateWorker (hedger) + { + } + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override; @@ -22,5 +29,4 @@ public: void terminate() override; void on_time(const TimeStamp&) override; }; - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp index 47890c5cc..da65f1cff 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp @@ -6,8 +6,6 @@ namespace bts{ namespace orderman{ -HedgerWaitingForFirstAckCancelledStateWorker::HedgerWaitingForFirstAckCancelledStateWorker () : _state_text ("WAITING_FOR_FIRST_ACK_CANCELLED"){} -void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} HedgerState HedgerWaitingForFirstAckCancelledStateWorker::state() const {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;} const std::string& HedgerWaitingForFirstAckCancelledStateWorker::state_text() const {return _state_text;} void HedgerWaitingForFirstAckCancelledStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h index 520896344..e4f5734e5 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h @@ -8,11 +8,17 @@ namespace orderman{ class HedgerWaitingForFirstAckCancelledStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; public: - HedgerWaitingForFirstAckCancelledStateWorker (); - void build_once (SingleFillHedger* hedger) override; + HedgerWaitingForFirstAckCancelledStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("WAITING_FOR_FIRST_ACK_CANCELLED") + {} + HedgerWaitingForFirstAckCancelledStateWorker (SingleFillHedger* hedger, const HedgerWaitingForFirstAckCancelledStateWorker&) + : HedgerWaitingForFirstAckCancelledStateWorker (hedger) + {} + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override; @@ -22,5 +28,4 @@ public: void terminate() override; void on_time(const TimeStamp&) override; }; - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp index 79df81bc8..9659a647f 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp @@ -4,8 +4,6 @@ namespace bts{ namespace orderman{ -HedgerWaitingForFirstAckStateWorker::HedgerWaitingForFirstAckStateWorker () : _state_text ("WAITING_FOR_FIRST_ACK"){} -void HedgerWaitingForFirstAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} HedgerState HedgerWaitingForFirstAckStateWorker::state() const {return HedgerState::WAITING_FOR_FIRST_ACK;} const std::string& HedgerWaitingForFirstAckStateWorker::state_text() const {return _state_text;} void HedgerWaitingForFirstAckStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h index feb115d43..468468186 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h @@ -8,11 +8,17 @@ namespace orderman{ class HedgerWaitingForFirstAckStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; public: - HedgerWaitingForFirstAckStateWorker (); - void build_once (SingleFillHedger* hedger) override; + HedgerWaitingForFirstAckStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("WAITING_FOR_FIRST_ACK") + {} + HedgerWaitingForFirstAckStateWorker (SingleFillHedger* hedger, const HedgerWaitingForFirstAckStateWorker&) + : HedgerWaitingForFirstAckStateWorker (hedger) + {} + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override; @@ -20,7 +26,6 @@ public: 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; + void on_time(const TimeStamp&) override; }; - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp index 4d7f33e26..61049315b 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -6,12 +6,6 @@ namespace bts{ namespace orderman{ -HedgerWorkingStateWorker::HedgerWorkingStateWorker () : _state_text ("WORKING"){} -void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger) -{ - _hedger = hedger; - _order_place_time = _hedger->_spreader.current_time(); -} HedgerState HedgerWorkingStateWorker::state() const {return HedgerState::WORKING;} const std::string& HedgerWorkingStateWorker::state_text() const {return _state_text;} void HedgerWorkingStateWorker::init() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h index 503277c01..d0d1b8e86 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h @@ -8,12 +8,20 @@ namespace orderman{ class HedgerWorkingStateWorker : public IHedgerStateWorker { private: - SingleFillHedger* _hedger; + SingleFillHedger* const _hedger; const std::string _state_text; TimeStamp _order_place_time; public: - HedgerWorkingStateWorker (); - void build_once (SingleFillHedger* hedger) override; + HedgerWorkingStateWorker (SingleFillHedger* hedger) + : _hedger(hedger), + _state_text ("WORKING") + {} + HedgerWorkingStateWorker (SingleFillHedger* hedger, const HedgerWorkingStateWorker& other) + : HedgerWorkingStateWorker (hedger) + { + _order_place_time = other._order_place_time; + } + void on_transition () override {} HedgerState state () const override; const std::string& state_text () const override; void init () override;