Spreader's bookkeepingdata_ptr is a unique_ptr and some stylistic changes to shorten line widths

This commit is contained in:
Taha Afzal committed 2018-06-06 10:11:39 -04:00
1 parent ed6affb6b5
commit 3a72a4a82e
9 files changed
+74 -83

No files matched your search

@@ -15,7 +15,7 @@ SpreaderOrder::SpreaderOrder()
_cancelled (false),
_cancel_timeout (5000),// TODO:get it from config
_active(true),
_bookkeeping_data_ptr(nullptr),
//_bookkeeping_data_ptr(nullptr),
_order_services(nullptr),
_reported_state(),
_state_worker(nullptr),
@@ -52,7 +52,7 @@ private:
// is false if created from disk
const bool _active;
// this is the main data
SpreaderBookkeepingData* _bookkeeping_data_ptr;
std::unique_ptr<SpreaderBookkeepingData> _bookkeeping_data_ptr;
// pointer kept to send reports
SpreaderOrderServices* _order_services;
// state thats sent out in report (its kept here vs creating a new one everytime)
@@ -73,21 +73,23 @@ public:
SingleFillHedger (SingleFillHedger&&);
SingleFillHedger& operator=(const SingleFillHedger&) = delete;
SingleFillHedger& operator=(SingleFillHedger&&) = delete;
//1. leave the start state and submit the order
// the a-f actions are associated with the state machine
// side effect actions
//a. leave the start state and submit the order
void init();
//2. called by the spreader when there is an order update
//b. called by the spreader when there is an order update
// reported by the exchange
void on_order_update(const SpreaderChildOrderState& order_update_message);
//3. called when the market data associated
//c. called when the market data associated
// with this security is changed
void on_book(bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book);
//4. called when the hedge order is cancelled, either
//d. called when the hedge order is cancelled, either
// manually or automatically
void cancel_hedge();
//5. immediatly terminates this hedger, without any attempts
//e. immediatly terminates this hedger, without any attempts
// to cancel the order
void terminate ();
//6. on the engine infrastructure time
//f. on the engine infrastructure time
void on_time(const bts::TimeStamp&);
// returns true if the quoter is in the final state, from which
// it will never come back
@@ -65,36 +65,38 @@ public:
SpreaderChildOrderState& child_order_state);
public:
SingleLegQuoter() = delete;
SingleLegQuoter (SingleLegQuoter&&);
SingleLegQuoter (const SingleLegQuoter&) = delete;
SingleLegQuoter(SingleLegQuoter&&); // implementation has an assert since it will not be called
SingleLegQuoter(const SingleLegQuoter&) = delete;
SingleLegQuoter& operator=(const SingleLegQuoter&) = delete;
SingleLegQuoter& operator=(SingleLegQuoter&&) = delete;
public:
//1. this is called only once. this all could have been passed in
// the a-h actions are associated with the state machine
// side effect actions
//a. this is called only once. this could have been passed in
// the constructor, but the spreader is created in 2 stages.
// all the memory is allocated in a slow path and then values
// are initialized on fast activation path
void one_time_activate (Price, Quantity);
//2. called by the spreader a change in
//b. called by the spreader a change in
// order status(or fills) is reported
// by the exchange
// by the exchange
void update_order_status(const SpreaderChildOrderState& u);
//3. called when the market data associated
//c. called when the market data associated
// with this security is changed
void on_book(bts::orderman::TickToTradeCorID cid, size_t leg_index, const bts::orderman::Book&);
//4. called when the order is cancelled, either
//d. called when the order is cancelled, either
// manually or automatically
void cancel_order();
//5. the quoter forgets everything and goes to the end state
//e. the quoter forgets everything and goes to the end state
void terminate ();
//6. time update
//f. time update
void on_time(const bts::TimeStamp&);
//7. this is called by the spreader when a quoting fill
//g. this is called by the spreader when a quoting fill
// (ie not hedging fill) happens on one of the quoting
// legs
void update_other_leg_fills(size_t leg_index, Quantity filled_quantity);
//8. called when the user modified the spreader order price or quantity
//h. called when the user modified the spreader order price or quantity
void update_order_price_quantity(Price price, Quantity quantity);
// true if the quoter has an active working order. the order can
// be in an unknown state, but as long as an order has been sent
@@ -125,8 +127,8 @@ public:
private:
bts::orderman::OrderKey _key() {return _child_order_state.order_key();}
TimeStamp _current_time () const {return _spreader.current_time();}
std::string _log_prefix()
{
// TODO: state out and move the string to a const
std::string _log_prefix(){
std::ostringstream oss;
oss << " spreader_order_key: " << _spreader.spreader_order_key();
oss << " sec_key: " << _this_leg_data.security_key();
@@ -24,7 +24,7 @@ void SpreaderEndStateWorker::on_init_recovered(const bts::api::orderman::OrderRe
void SpreaderEndStateWorker::on_activate(Price price, Quantity quantity,
SpreaderOrderServices&){
// this can only happen if the security could not be resolved
// resulting in START->END. however on_active will could still
// resulting in START->END. however on_active could still
// be called
bts_assert (!_spreader->_bookkeeping_data().all_legs_resolved());
_spreader->_bookkeeping_data().update_order(price, quantity);
@@ -6,26 +6,27 @@ namespace orderman {
class SpreaderOrder;
class SpreaderEndStateWorker : public ISpreaderStateWorker
{
class SpreaderEndStateWorker : public ISpreaderStateWorker{
private:
SpreaderOrder* const _spreader;
public:
SpreaderEndStateWorker (SpreaderOrder*);
void on_transition() override;
SpreaderState state() const override;
void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override;
void on_transition() override;
void on_init_new(const api::orderman::OrderDefinition&,
const SpreaderPreActivationOrderServices&) override;
void on_init_recovered(const bts::api::orderman::OrderRecord&,
const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, SpreaderOrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override;
void on_book(TickToTradeCorID, const Book&) override;
void on_time(const TimeStamp&) override;
void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_error(SpreaderLegData& leg_data) override;
void on_quoter_order_fill(SpreaderLegData& leg_data) override;
void on_quoter_order_status_update(SpreaderLegData& leg_data) override;
void on_hedger_order_error(SingleFillHedger&) override;
void on_hedger_order_update(SingleFillHedger&) override;
void on_check_termination () override;
void on_check_termination() override;
};
}}
@@ -22,10 +22,10 @@ void SpreaderStartStateWorker::on_init_new(const api::orderman::OrderDefinition&
bts_assert(!_spreader->_inited());
std::vector<LegPropertyData> spreader_legs;
if (SpreaderUtils::resolve_synthetic_spread (spreader_pao_services, order_def, spreader_legs, false))
_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs);
_spreader->_bookkeeping_data_ptr = std::make_unique<SpreaderBookkeepingData>(*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs);
else
{
_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector<LegPropertyData>());
_spreader->_bookkeeping_data_ptr = std::make_unique<SpreaderBookkeepingData>(*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector<LegPropertyData>());
// if securities can not be resolved, the order is terminated
LOG(OrderMan, Error, "SpreaderStartStateWorker.on_init_new key: {} , could not resolve securities", _spreader->key().value());
std::string msg = "Could not resolve securities";
@@ -36,7 +36,7 @@ void SpreaderStartStateWorker::on_init_recovered(const bts::api::orderman::Order
{
bts_assert(!_spreader->_inited());
// we are not handling this yet, so lets send it directly to END
_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector<LegPropertyData>());
_spreader->_bookkeeping_data_ptr = std::make_unique<SpreaderBookkeepingData>(*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector<LegPropertyData>());
LOG(OrderMan, Warn, "SpreaderStartStateWorker.on_init_recovered key: {} , going to END", _spreader->key().value());
std::string msg = "Recovered spreader orders and not supported";
_spreader->_transform_to_END (&msg);
@@ -9,50 +9,47 @@ SpreaderWorkingStateWorker::SpreaderWorkingStateWorker (SpreaderOrder* spreader)
:
_spreader(spreader)
{}
SpreaderState SpreaderWorkingStateWorker::state() const {return SpreaderState::WORKING;}
void SpreaderWorkingStateWorker::on_transition()
{}
void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&)
{
SpreaderState SpreaderWorkingStateWorker::state() const {
return SpreaderState::WORKING;
}
void SpreaderWorkingStateWorker::on_transition(){
}
void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&,
const SpreaderPreActivationOrderServices&){
bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_new is an illegal operation");
}
void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&)
{
void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&,
const SpreaderPreActivationOrderServices&){
bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_recovered is an illegal operation");
}
void SpreaderWorkingStateWorker::on_activate(Price, Quantity, SpreaderOrderServices&)
{
void SpreaderWorkingStateWorker::on_activate(Price, Quantity,
SpreaderOrderServices&){
bts_assert_msg (false, "SpreaderWorkingStateWorker::on_activate is an illegal operation");
}
void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity)
{
if (_spreader->_quoters_can_accept_modification())
{
void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity){
if (_spreader->_quoters_can_accept_modification()){
_spreader->_set_price_quantity (price, quantity);
// updating all active quoters, nothing to do with the hedgers
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++)
{
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){
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);
}
}
}
void SpreaderWorkingStateWorker::on_cancel()
{
void SpreaderWorkingStateWorker::on_cancel(){
_spreader->_cancel_orders (true, true);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, const bts::orderman::Book& book)
{
void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid,
const Book& book){
SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data();
// 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.update_book(book);
// sending md to all quoters
for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++)
{
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);
@@ -61,11 +58,9 @@ void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, co
for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
md_leg.get_hedger(h_idx).on_book(cid, book);
}
void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts)
{
void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts){
SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data();
for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++)
{
for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++){
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);
@@ -73,15 +68,13 @@ void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts)
leg_data.get_hedger(h_idx).on_time (ts);
}
}
void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data)
{
void SpreaderWorkingStateWorker::on_quoter_order_error(SpreaderLegData& leg_data){
// this is because the error message could also have status changes
leg_data.quoter().update_order_status (leg_data.order_update_message());
_spreader->_cancel_orders (true, true);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data)
{
void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data){
// this is the most complex part of the spreader. the following needs to be done
// 1. tell other quoters about it (so they reduce their sizes)
// 2. launch a new hedger
@@ -101,11 +94,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg
LOG(OrderMan, Info, "SpreaderWorkingStateWorker::on_quoter_order_fill order: key: {} order_key: {} status: {} filled_qty: {} last_price: {}",
_spreader->key(), order_update_message.order_key(), order_update_message.status(), order_update_message.last_update_filled_quantity(), order_update_message.last_update_filled_price());
bts_assert (order_update_message.last_update_filled_quantity().value() > 0);
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++)
{
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); 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 (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())
@@ -140,10 +131,4 @@ void SpreaderWorkingStateWorker::on_check_termination()
if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state())
_spreader->_transform_to_END ();
}
bool SpreaderWorkingStateWorker::_is_leg_filled (size_t leg_idx) const
{
const SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(leg_idx);
Quantity leg_target_qty = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_data.leg_property_data(), _spreader->_bookkeeping_data().quantity());
return leg_data.total_fills().value() >= leg_target_qty.value();
}
}}
@@ -14,21 +14,22 @@ public:
SpreaderWorkingStateWorker (SpreaderOrder*);
void on_transition() override;
SpreaderState state() const override;
void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override;
void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity, SpreaderOrderServices&) override;
void on_init_new(api::orderman::OrderDefinition const&,
const SpreaderPreActivationOrderServices&) override;
void on_init_recovered(const bts::api::orderman::OrderRecord&,
const SpreaderPreActivationOrderServices&) override;
void on_activate(Price, Quantity,
SpreaderOrderServices&) override;
void on_update(Price, Quantity) override;
void on_cancel() override;
void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override;
void on_book(TickToTradeCorID,
const Book&) override;
void on_time(const TimeStamp&) override;
void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override;
void on_quoter_order_error(SpreaderLegData& leg_data) override;
void on_quoter_order_fill(SpreaderLegData& leg_data) override;
void on_quoter_order_status_update(SpreaderLegData& leg_data) override;
void on_hedger_order_error(SingleFillHedger&) override;
void on_hedger_order_update(SingleFillHedger&) override;
void on_check_termination () override;
private:
bool _is_leg_filled (size_t leg_idx) const;
};
}}