Files
spark/src/lib/orderman/limiter/Limiter.cpp
T
2018-08-01 17:11:17 +00:00

104 lines
3.9 KiB
C++

#include "Limiter.h"
#include "LimitStore.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/api/services/AdminService.server.pb.h"
namespace bts {
namespace orderman {
struct Limiter::PImpl {
std::map<uint32_t,api::Security const*> sec_map;
std::unique_ptr<LimitStore> limit_store;
PImpl()
:
sec_map(),
limit_store(std::make_unique<LimitStore>(bts::api::admin::AdminData(), sec_map))
{
}
};
Limiter::Limiter() : me(new PImpl()) {}
Limiter::~Limiter() {}
void Limiter::update(api::admin::AdminData const& admin_data) {
LOG(OrderMan, Info, "Limiter::update");
_reset(admin_data);
}
void Limiter::add_securities(std::vector<api::Security const*> const& new_securities){
LOG(OrderMan, Info, "Limiter::add_securities {} securities", me->sec_map.size());
for(const api::Security* s : new_securities)
_add_security(s);
_reset(me->limit_store->admin_data());
}
void Limiter::add_security(api::Security const & security) {
_add_security(&security);
_reset(me->limit_store->admin_data());
}
void Limiter::add(api::Security const &security, AccountID account_id, api::Side side, Quantity quantity){
if (!_contains_security(&security))
add_security(security);
if (!me->limit_store->has_account(account_id)){
// add a temporary account, so trades can go in there
_add_account_and_reset(account_id);
}
me->limit_store->add_position(security, account_id, side, quantity);
}
void Limiter::remove(api::Security const &security, AccountID account_id, api::Side side, Quantity quantity) {
if (!_contains_security(&security))
add_security(security);
if (!me->limit_store->has_account(account_id)){
_add_account_and_reset(account_id);
}
me->limit_store->remove_position(security, account_id, side, quantity);
}
Limiter::LimiterQueryResult Limiter::can_trade(UserID user_id, AccountID account_id) const {
LimiterQueryResult rv = me->limit_store->can_trade(user_id, account_id);
//rv.ok = true;
return rv;
}
Limiter::LimiterQueryResult Limiter::can_send_new_order(AccountID account_id,
api::Security const & security,
api::Side side,
Quantity quantity) const {
LimiterQueryResult rv = me->limit_store->can_send_new_order(account_id, security, side, quantity);
//rv.ok = true;
return rv;
}
Limiter::LimiterQueryResult Limiter::can_update_order(AccountID account_id,
api::Security const & security,
api::Side side, Quantity from,
Quantity to) const {
LimiterQueryResult rv = me->limit_store->can_update_order(account_id, security, side, from, to);
//rv.ok = true;
return rv;
}
void Limiter::_add_account_and_reset(AccountID account_id){
bts::api::admin::AdminData admin_data_catchup = me->limit_store->admin_data();
bts::api::admin::BTSAccount* new_account = admin_data_catchup.mutable_accounts()->Add();
new_account->set_id(account_id.value());
new_account->set_is_active(true);
update(admin_data_catchup);
}
void Limiter::_reset (const bts::api::admin::AdminData& admin_data){
LimitStore* new_store = new LimitStore(admin_data, me->sec_map);
new_store->copy_positions_from(*me->limit_store);
me->limit_store.reset(new_store);
}
void Limiter::_add_security (const api::Security* sec){
if (!_contains_security(sec)){
me->sec_map.insert(std::pair<uint32_t,const api::Security*>(sec->id(), sec));
if (sec->has_spread())
for(const auto& leg : sec->spread().legs())
_add_security(&leg.security());
}
}
bool Limiter::_contains_security (const api::Security* security){
return me->sec_map.find(security->id()) != me->sec_map.end();
}
LimitStore& Limiter::limit_store(){
return *me->limit_store;
}
}}