SPARK-331 ISpreaderStateWorker getting rid of on_external_error and on_disconnect

This commit is contained in:
Taha Afzal committed 2018-01-22 18:38:48 -05:00
1 parent 70aa373a8f
commit ff82df6e99
11 files changed
+150 -150

No files matched your search

@@ -24,11 +24,12 @@ public:
// constructed here
virtual void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) = 0;
// 2. this is the end of the construction cycle. should happen
// after on_init_new and before all other calls
// after on_init_new and before all other calls. market data subs
// and quoter order creation happens here
virtual void on_activate(Price, Quantity, orderman2::OrderServices &) = 0;
// 3. called if the venue disconnects. will only be called if there
// was previous on_connect()
virtual void on_disconnect() = 0;
virtual void on_disconnect() {}
// 4. new on_update
virtual void on_update(Price, Quantity) = 0;
// 5. called when the user cancels an order
@@ -49,7 +50,7 @@ public:
virtual void on_hedger_order_update(OrderKey child_k, api::orderman::OrderStatus, Quantity filled_quantity, Price average_price) = 0;
// 13. called when an external error occurs (which could be a risk limit
// breach or a system issue)
virtual void on_external_error(std::string const&) = 0;
virtual void on_external_error(std::string const&) {}
// 14. is called periodically
virtual void on_check_termination () = 0;
// 15.
@@ -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_val (0, Price(0), Quantity(0)),
_bookkeeping_data_val (0),
_state_worker(nullptr)
{
LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() );
@@ -35,7 +35,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db,
_active (true),
_real_orders (!bts::utils::internal::is_unittest_environment()),
_create_order_request (cor),
_bookkeeping_data_val (cor.spreader().execution_strategy().leg_params_map().size(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity())),
_bookkeeping_data_val (cor.spreader().execution_strategy().leg_params_map().size()),
_state_worker(nullptr)
{
LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value());
@@ -17,15 +17,7 @@ void SpreaderStartStateWorker::on_init_new(const api::orderman2::OrderDefinition
{
std::vector<LegPropertyData> spreader_legs;
if (SpreaderUtils::resolve_synthetic_spread (pre_services.sec_db, order_def, spreader_legs))
{
// create SpreaderBookData
_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (spreader_legs.size(), Price(0), Quantity(0));
for (auto l_it = spreader_legs.begin(); l_it != spreader_legs.end(); l_it++)
{
const LegPropertyData& leg_data = *l_it;
_spreader->_bookkeeping_data_ptr->add_leg (leg_data, *_spreader, pre_services);
}
}
_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, pre_services, _spreader->key(), spreader_legs);
else
{
// if securities can not be resolved, the order is terminated
@@ -37,31 +29,32 @@ void SpreaderStartStateWorker::on_init_new(const api::orderman2::OrderDefinition
void SpreaderStartStateWorker::on_activate(Price price, Quantity quantity, orderman2::OrderServices& order_services)
{
// 1. update price, qty
_spreader->_bookkeeping_data_ptr->update_order (price, quantity);
_spreader->_bookkeeping_data().update_order (price, quantity);
// 2. activate order builders
_spreader->_bookkeeping_data_ptr->activate_order_builders(order_services);
// 3. sub to order
for (size_t l_idx = 0; l_idx < _spreader->_bookkeeping_data().n_legs(); l_idx++)
{
SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(l_idx);
leg_data.quoter_order_builder().activate(order_services);
leg_data.hedger_order_builder().activate(order_services);
}
// 3. sub to child orders order
order_services.child_updates.sub(_spreader->key(), [this](const bts::orderman2::OrderStateUpdateEvent& os) { _spreader->_on_child_order_update (os);});
// 4. sub to market data
for (size_t l_idx = 0; l_idx < _spreader->_bookkeeping_data_ptr->n_legs(); l_idx++)
for (size_t l_idx = 0; l_idx < _spreader->_bookkeeping_data().n_legs(); l_idx++)
{
order_services.book_updates.sub(_spreader->_bookkeeping_data_ptr->get_leg_data(l_idx).leg_property_data().leg_security_key(),
order_services.book_updates.sub(_spreader->_bookkeeping_data().get_leg_data(l_idx).leg_property_data().leg_security_key(),
[this](const bts::orderman2::BookUpdateEvent& bk_event)
{_spreader->_on_book_update (bk_event);});
}
// // 5. get child orders
// 5. get child orders
for (size_t l_idx = 0; l_idx < _spreader->_bookkeeping_data_ptr->n_legs(); l_idx++)
{
SpreaderLegData& leg_data = _spreader->_bookkeeping_data_ptr->get_leg_data(l_idx);
SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(l_idx);
bts::orderman2::ChildOrder child_order = leg_data.quoter_order_builder().build();
bts_assert (child_order.key().value() > 100);
//leg_data.order_update_message().child_order = leg_data.quoter_order_builder().build();
leg_data.order_update_message().re_init(child_order);
}
// 6. transofrm state
}
void SpreaderStartStateWorker::on_disconnect()
{
bts_assert_msg (false, "SpreaderStartStateWorker::on_disconnect is an illegal operation");
_spreader->_transform_to_WORKING ();
}
void SpreaderStartStateWorker::on_update(Price, Quantity)
{
@@ -77,6 +70,7 @@ void SpreaderStartStateWorker::on_book(bts::orderman2::TickToTradeCorID, const b
}
void SpreaderStartStateWorker::on_time(const TimeStamp&)
{
bts_assert_msg (false, "SpreaderStartStateWorker::on_time is an illegal operation");
}
void SpreaderStartStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*)
{
@@ -98,11 +92,8 @@ void SpreaderStartStateWorker::on_hedger_order_update(OrderKey, api::orderman::O
{
bts_assert_msg (false, "SpreaderStartStateWorker::on_hedger_order_update is an illegal operation");
}
void SpreaderStartStateWorker::on_external_error(std::string const&)
{
_spreader->_transform_to_END ();
}
void SpreaderStartStateWorker::on_check_termination ()
{
bts_assert_msg (false, "SpreaderStartStateWorker::on_check_termination is an illegal operation");
}
}}
@@ -20,7 +20,6 @@ public:
const std::string& state_text () const override;
void on_init_new(api::orderman2::OrderDefinition const&, const orderman2::PreActivationOrderServices&) override;
void on_activate(Price, Quantity, orderman2::OrderServices&) override;
void on_disconnect() override;
void on_update(Price, Quantity) override;
void on_cancel() override;
void on_book(bts::orderman2::TickToTradeCorID, const bts::orderman2::Book&) override;
@@ -30,7 +29,6 @@ public:
void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus) override;
void on_hedger_order_error(OrderKey child_k, api::orderman::OrderStatus, Quantity filled_quantity, Price average_price, std::string const *reject) override;
void on_hedger_order_update(OrderKey child_k, api::orderman::OrderStatus, Quantity filled_quantity, Price average_price) override;
void on_external_error(std::string const&) override;
void on_check_termination () override;
};
@@ -116,24 +116,24 @@ void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata()
}
void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quoters()
{
ISpreaderManager& me_ref = *_spreader;
const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader();
spark::ExecutionStrategy execution_strategy = cor.execution_strategy();
const bts::api::Security& sec = cor.security();
size_t leg_idx = 0;
for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it)
{
// i. immutable property data for this leg
const bts::api::ContractLeg& leg = *it;
auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id());
bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end());
api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg);
LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side);
// 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());
_spreader->_bookkeeping_data_val.add_leg (leg_property_data, child_order, me_ref);
leg_idx++;
}
// ISpreaderManager& me_ref = *_spreader;
// const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader();
// spark::ExecutionStrategy execution_strategy = cor.execution_strategy();
// const bts::api::Security& sec = cor.security();
// size_t leg_idx = 0;
// for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it)
// {
// // i. immutable property data for this leg
// const bts::api::ContractLeg& leg = *it;
// auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id());
// bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end());
// api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg);
// LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side);
// // 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());
// _spreader->_bookkeeping_data_val.add_leg (leg_property_data, child_order, me_ref);
// leg_idx++;
// }
}
}}
+26 -26
View File
@@ -9,32 +9,32 @@
namespace bts {
namespace orderman {
SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader,
LegPropertyData this_leg_property,
size_t n_spreader_legs,
bts::Price spread_order_price,
bts::Quantity spread_order_quantity,
bts::orderman::SpreaderOrderBase::ChildOrder child_order)
:
_two_legged (n_spreader_legs == 2),
_spreader(spreader),
_this_leg_data (this_leg_property),
_n_spreader_legs (n_spreader_legs),
_order (child_order),
_price_quantity_state(QuoteLegPriceQuantityState(spread_order_price, Quantity(SpreaderUtils::get_leg_quantity_from_spreader_quantity (this_leg_property, spread_order_quantity)))),
_is_permenantly_cancelled (false),
_worker(nullptr)
{
if (!_two_legged)
{
for (size_t q_idx = 0; q_idx < _n_spreader_legs; q_idx++)
{
_drivers_commited.push_back (QuoterLegDriverData());
_drivers_temp_usage.push_back (QuoterLegDriverData());
}
}
_transform_to_START ();
}
// SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader,
// LegPropertyData this_leg_property,
// size_t n_spreader_legs,
// bts::Price spread_order_price,
// bts::Quantity spread_order_quantity,
// bts::orderman::SpreaderOrderBase::ChildOrder child_order)
// :
// _two_legged (n_spreader_legs == 2),
// _spreader(spreader),
// _this_leg_data (this_leg_property),
// _n_spreader_legs (n_spreader_legs),
// _order (child_order),
// _price_quantity_state(QuoteLegPriceQuantityState(spread_order_price, Quantity(SpreaderUtils::get_leg_quantity_from_spreader_quantity (this_leg_property, spread_order_quantity)))),
// _is_permenantly_cancelled (false),
// _worker(nullptr)
// {
// if (!_two_legged)
// {
// for (size_t q_idx = 0; q_idx < _n_spreader_legs; q_idx++)
// {
// _drivers_commited.push_back (QuoterLegDriverData());
// _drivers_temp_usage.push_back (QuoterLegDriverData());
// }
// }
// _transform_to_START ();
// }
SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader,
LegPropertyData this_leg_property,
size_t n_spreader_legs)
+6 -6
View File
@@ -54,12 +54,12 @@ public:
SingleLegQuoter(ISpreaderManager& spreader,
LegPropertyData this_leg_property,
size_t n_spreader_legs);
SingleLegQuoter(ISpreaderManager& spreader,
LegPropertyData this_leg_property,
size_t n_spreader_legs,
bts::Price spread_order_price,
bts::Quantity spread_order_quantity,
bts::orderman::SpreaderOrderBase::ChildOrder child_order);
// SingleLegQuoter(ISpreaderManager& spreader,
// LegPropertyData this_leg_property,
// size_t n_spreader_legs,
// bts::Price spread_order_price,
// bts::Quantity spread_order_quantity,
// bts::orderman::SpreaderOrderBase::ChildOrder child_order);
public:
SingleLegQuoter() = delete;
SingleLegQuoter (SingleLegQuoter&&);
@@ -15,12 +15,12 @@ class SpreaderHedgerData;
class SpreaderBookkeepingData
{
private:
const size_t _n_legs;
std::vector<SpreaderLegData> _leg_data;
std::vector<SingleLegQuoter> _quoters;
const size_t _n_legs;
std::vector<bts::orderman2::OrderBuilder> _quoter_order_builders;
std::vector<bts::orderman2::OrderBuilder> _hedger_order_builders;
std::vector<SingleLegQuoter> _quoters;
std::vector<std::vector<SpreaderHedgerData>> _hedgers;
std::vector<SpreaderLegData> _leg_data;
boost::container::flat_map<uint32_t, size_t> _sec_key_to_index;
Price _price;
Quantity _quantity;
@@ -33,39 +33,27 @@ public:
_quoters.reserve (n_legs);
_hedgers.reserve (n_legs);
}
SpreaderBookkeepingData(size_t n_legs, Price price, Quantity quantity)
:
_n_legs (n_legs),
_price (price),
_quantity (quantity)
{
_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()));
}
void add_leg (const LegPropertyData& leg_property_data,
ISpreaderManager& spreader_manager,
const bts::orderman2::PreActivationOrderServices& pao_services)
{
_quoters.emplace_back(spreader_manager, leg_property_data, _n_legs);
_quoter_order_builders.emplace_back(bts::orderman2::OrderKey(0), leg_property_data.quoter_order_definition(), pao_services, 10);
_hedger_order_builders.emplace_back(bts::orderman2::OrderKey(0), leg_property_data.hedger_order_definition(), pao_services, 10);
_hedgers.emplace_back ();
_leg_data.emplace_back(leg_property_data, _quoters.back(), _quoter_order_builders.back(), _hedger_order_builders.back(), _hedgers.back ());
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()));
}
SpreaderBookkeepingData (ISpreaderManager& spreader_manager,
const bts::orderman2::PreActivationOrderServices& pao_services,
bts::orderman2::OrderKey spreader_order_key,
const std::vector<LegPropertyData>& legs)
: _n_legs(legs.size())
{
_quoters.reserve (_n_legs);
_hedgers.reserve (_n_legs);
_leg_data.reserve (_n_legs);
for (size_t l_idx = 0; l_idx < legs.size(); l_idx++)
{
const LegPropertyData& leg_property_data = legs[l_idx];
_quoter_order_builders.emplace_back(spreader_order_key, leg_property_data.quoter_order_definition(), pao_services, 10);
_hedger_order_builders.emplace_back(spreader_order_key, leg_property_data.hedger_order_definition(), pao_services, 10);
_quoters.emplace_back(spreader_manager, leg_property_data, _n_legs);
_hedgers.emplace_back ();
_leg_data.emplace_back(leg_property_data, _quoters.back(), _quoter_order_builders.back(), _hedger_order_builders.back(), _hedgers.back ());
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)
{
boost::container::flat_map<uint32_t, size_t>::const_iterator l_it = _sec_key_to_index.find(security_key.value());
@@ -82,7 +70,7 @@ public:
bts_assert(index < _leg_data.size());
return _leg_data[index];
}
size_t n_legs() const { return _leg_data.size(); }
size_t n_legs() const { return _n_legs; }
SpreaderLegData* find_leg_from_quoter_orderkey(OrderKey order_key)
{
for (auto q_it = _leg_data.begin(); q_it != _leg_data.end(); q_it++)
@@ -120,13 +108,5 @@ public:
_price = price;
_quantity = quantity;
}
// TODO, expose it through the SpreaderLegData
void activate_order_builders (bts::orderman2::OrderServices& order_services)
{
for (auto it=_quoter_order_builders.begin();it!=_quoter_order_builders.end();it++)
it->activate(order_services);
for (auto it=_hedger_order_builders.begin();it!=_hedger_order_builders.end();it++)
it->activate(order_services);
}
};
}}
@@ -2,6 +2,8 @@
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/api/services/OrderService2.pb.h"
#include "server/sparkd/orderman2/events/OrderStateUpdateEvent.h"
#include "SpreaderUtils.h"
namespace bts {
@@ -18,6 +20,7 @@ private:
bts::orderman2::ChildOrder _child_order;
orderman::OrderKey _order_key;
api::orderman::OrderStatus _status;
api::orderman2::OrderStatus _order_status;
Price _average_price;
Quantity _filled_quantity;
Price _last_update_filled_price;
@@ -49,7 +52,9 @@ public:
init (order_key);
}
orderman::OrderKey order_key () const {return _order_key;}
bts::orderman2::OrderKey key() {return _child_order.key();}
api::orderman::OrderStatus status () const {return _status;}
bts::api::orderman2::OrderStatus order_status () {return _order_status;}
Quantity filled_quantity () const {return _filled_quantity;}
Price last_update_filled_price () const {return _last_update_filled_price;}
Quantity last_update_filled_quantity () const {return _last_update_filled_quantity;}
@@ -57,7 +62,7 @@ public:
bool acknowledged () const {return SpreaderUtils::order_acknowledged (_status);}
bool has_error() const { return _has_error; }
bool has_fills() const {return _last_update_filled_quantity.value() != 0;}
//bts::orderman2::ChildOrder& child_order() {return _child_order;}
bts::orderman2::ChildOrder& child_order() {return _child_order;}
void init (orderman::OrderKey order_key)
{
@@ -69,9 +74,37 @@ public:
_last_update_filled_quantity = Quantity(0);
_has_error = false;
}
void update(api::orderman::OrderStatus status)
void re_init (bts::orderman2::ChildOrder& child_order)
{
_status = status;
_child_order = std::move(child_order);
_zero_out();
}
void _zero_out ()
{
_order_status = bts::api::orderman2::OrderStatus::ORDER_STATUS_INACTIVE;
_average_price = Price(0);
_filled_quantity = Quantity (0);
_last_update_filled_price = Price(0);
_last_update_filled_quantity = Quantity(0);
}
void update (const bts::orderman2::OrderStateUpdateEvent& ev)
{
_order_status = ev.state.status();
bts_assert(ev.key == _child_order.key());
bts_assert(ev.state.filled_quantity() >= _filled_quantity.value());
_order_status = ev.state.status();
_last_update_filled_quantity = Quantity(ev.state.filled_quantity() - _filled_quantity.value());
if (_last_update_filled_quantity.value() > 0)
{
double sum = ev.state.avg_price() * ev.state.filled_quantity(),
previous_sum = _average_price.value() * _filled_quantity.value();
_last_update_filled_price = Price((sum - previous_sum)/_last_update_filled_quantity.value());
}
_filled_quantity = Quantity(ev.state.filled_quantity());
_average_price = Price(ev.state.avg_price());
}
void update(api::orderman::OrderStatus)
{
}
//the filled quantity and average price are the total
//over the course of the order (this is how the order
+6 -18
View File
@@ -28,21 +28,9 @@ private:
bts::orderman2::OrderBuilder* _quoter_order_builder;
bts::orderman2::OrderBuilder* _hedger_order_builder;
std::vector<SpreaderHedgerData>& _hedger_data_vector;
SpreaderChildOrderState _order_update_message;
SpreaderChildOrderState _child_order_state;
bts::orderman2::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),
_quoter_order_builder (nullptr),
_hedger_order_builder (nullptr),
_hedger_data_vector (hedger_data_vector),
_order_update_message (child_order.order_key()),
_book()
{}
public:
SpreaderLegData (const LegPropertyData& leg_property_data,
SingleLegQuoter& quoter,
bts::orderman2::OrderBuilder& quoter_order_builder,
@@ -53,7 +41,7 @@ public:
_quoter_order_builder (&quoter_order_builder),
_hedger_order_builder (&hedger_order_builder),
_hedger_data_vector (hedger_data_vector),
_order_update_message (OrderKey(0)),
_child_order_state (OrderKey(0)),
_book()
{
}
@@ -63,7 +51,7 @@ public:
: _leg_property_data (other._leg_property_data),
_quoter (other._quoter),
_hedger_data_vector (other._hedger_data_vector),
_order_update_message (std::move(other._order_update_message)),
_child_order_state (std::move(other._child_order_state)),
_book()
{
bts_assert (false);
@@ -74,8 +62,8 @@ public:
const LegPropertyData& leg_property_data() const {return _leg_property_data;}
SingleLegQuoter& quoter() {return _quoter;}
const bts::orderman2::Book& book () const {return _book;}
SpreaderChildOrderState& order_update_message () {return _order_update_message;}
OrderKey order_key() {return _order_update_message.order_key();}
SpreaderChildOrderState& order_update_message () {return _child_order_state;}
OrderKey order_key() {return _child_order_state.order_key();}
bts::orderman2::OrderBuilder& quoter_order_builder() {return *_quoter_order_builder;}
bts::orderman2::OrderBuilder& hedger_order_builder() {return *_hedger_order_builder;}
// returns the number of active hedgers
@@ -200,6 +200,15 @@ public:
order_status == api::orderman::OrderStatus::OS_REJECTED ||
order_status == api::orderman::OrderStatus::OS_EXPIRED;
}
static bool order_in_terminal_state(bts::api::orderman2::OrderStatus)
{
return true;
}
static bool order_acknowledged (bts::api::orderman2::OrderStatus)
{
// any state but that means order is ack'ed
return true;
}
/**********************************************************************/
/****************************Market Data*******************************/
/**********************************************************************/