SPARK-327 (restrcutured SpreaderBookkeepingData to be more efficent)
This commit is contained in:
1 parent
8fe166633d
commit
d1861cb404
25 files changed
+409
-311
No files matched your search
@@ -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<SpreaderLegData>(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))),
|
||||
//_bookkeeping_data_ptr (new SpreaderBookkeepingData (std::vector<SpreaderLegData>(), 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);
|
||||
}
|
||||
|
||||
+2
-2
@@ -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)
|
||||
{
|
||||
|
||||
+3
-12
@@ -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<SpreaderLegData> 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()));
|
||||
}
|
||||
}}
|
||||
+9
-9
@@ -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)
|
||||
{
|
||||
|
||||
@@ -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<LegPropertyData> legs;
|
||||
legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3);
|
||||
std::vector<Book> 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<SpreaderLegData> 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<LegPropertyData> legs;
|
||||
// legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3);
|
||||
// std::vector<Book> 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<SpreaderLegData> 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<Temp> 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<Temp> 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);
|
||||
}
|
||||
}}
|
||||
|
||||
@@ -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*******************************/
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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**********************************/
|
||||
/*********************************************************************************/
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -12,25 +12,34 @@ class SpreaderHedgerData;
|
||||
class SpreaderBookkeepingData
|
||||
{
|
||||
private:
|
||||
const size_t _n_legs;
|
||||
std::vector<SpreaderLegData> _leg_data;
|
||||
std::vector<SingleLegQuoter> _quoters;
|
||||
std::vector<std::vector<SpreaderHedgerData>> _hedgers;
|
||||
boost::container::flat_map<uint32_t, size_t> _sec_key_to_index;
|
||||
Price _price;
|
||||
Quantity _quantity;
|
||||
public:
|
||||
SpreaderBookkeepingData ()
|
||||
: _leg_data (std::vector<SpreaderLegData>()),
|
||||
_sec_key_to_index (boost::container::flat_map<uint32_t, size_t>()),
|
||||
_price (Price(0)),
|
||||
_quantity (Quantity(0))
|
||||
{}
|
||||
SpreaderBookkeepingData(const std::vector<SpreaderLegData>& 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<uint32_t, size_t>(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<uint32_t, size_t>(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<SpreaderHedgerData>& 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;
|
||||
}
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -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;}
|
||||
};
|
||||
}}
|
||||
@@ -6,6 +6,8 @@
|
||||
#include "SpreaderChildOrderState.h"
|
||||
#include <google/protobuf/util/message_differencer.h>
|
||||
|
||||
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<SpreaderHedgerData>& _hedger_data_vector;
|
||||
SpreaderChildOrderState _order_update_message;
|
||||
std::vector<SpreaderHedgerData> _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<SpreaderHedgerData>& 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<SpreaderHedgerData>& 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;}
|
||||
};
|
||||
}}
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -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()
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
}}
|
||||
-2
@@ -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()
|
||||
|
||||
+10
-4
@@ -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;
|
||||
};
|
||||
|
||||
}}
|
||||
-2
@@ -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()
|
||||
|
||||
+9
-4
@@ -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;
|
||||
};
|
||||
|
||||
}}
|
||||
-2
@@ -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()
|
||||
|
||||
+10
-5
@@ -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;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -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()
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user