Files
spark/src/server/sparkd/risk_limits/RiskLimitManager.cpp
T
2017-09-19 22:49:18 +00:00

124 lines
4.0 KiB
C++

#include "RiskLimitManager.h"
#include "server/sparkd/risk_limits/RiskLimiter.h"
#include "server/sparkd/order_man/OrderCreate.h"
#include "server/sparkd/order_man/OrderUpdate.h"
#include "server/sparkd/order_man/OrderState.h"
#include "lib/config/config.h"
#include "lib/config/protos/Account.pb.h"
#include "lib/config/protos/User.pb.h"
#include "lib/utils/bts_assert.h"
#include "lib/logging/logging.h"
#include <boost/container/flat_map.hpp>
#include <tuple>
using namespace bts::orderman;
namespace bts {
namespace risklimits {
using OperatorMap = boost::container::flat_map<std::string, config::Operator>;
using KeyType = std::tuple<AccountName, orderman::OperatorID, orderman::SymbolName>;
using LimiterMap = boost::container::flat_map<KeyType, std::shared_ptr<RiskLimiter>>;
struct RiskLimitManager::PImpl
{
OperatorMap operator_map;
LimiterMap limiter_map;
PImpl() :
operator_map(), limiter_map()
{
auto users = config::get<config::UserCfg>();
for(int i = 0; i < users.user_size(); i++)
{
auto user = users.user(i);
for(int j = 0; i < user.operators_size(); j++)
operator_map[user.operators(j).operator_id().id()] = user.operators(j);
}
auto accts = config::get<config::AccountCfg>();
for(int i = 0; i < accts.accounts_size(); i++)
{
const auto& acct = accts.accounts(i).account();
const auto& limit = accts.accounts(i).limits();
for(auto j = limit.begin(); j != limit.end(); j++)
{
for(int k = 0; k < acct.allowed_operators_size(); k++)
{
auto allowed = operator_map.find(acct.allowed_operators(k).id());
if(allowed != operator_map.end())
{
orderman::OperatorID opid = to<OperatorID>(allowed->second.operator_id().id());
KeyType key(to_accountname(acct), opid, to_symbolname(j->first));
RiskLimiter* lim = new RiskLimiter(std::get<0>(key), std::get<1>(key), std::get<2>(key));
limiter_map[key] = std::shared_ptr<RiskLimiter>(lim);
lim->on_account_update(acct);
lim->on_operator_update(allowed->second);
lim->on_risk_limit_update(j->second);
}
}
}
}
}
orderman::SymbolName to_symbolname(SecurityKey)
{
return to_symbolname("ES");
}
orderman::SymbolName to_symbolname(const std::string& key)
{
return orderman::SymbolName(key);
}
orderman::AccountName to_accountname(const config::Account& key)
{
return to<orderman::AccountName> (key.account_id());
}
RiskLimiter& find_limiter(AccountName acctname, orderman::OperatorID opid, orderman::SymbolName symbolname)
{
KeyType key(acctname, opid, symbolname);
auto lim = limiter_map.find(key);
if(lim != limiter_map.end())
return *lim->second;
else
{
RiskLimiter* lim = new RiskLimiter(std::get<0>(key), std::get<1>(key), std::get<2>(key));
auto ptr = std::shared_ptr<RiskLimiter>(lim);
limiter_map[key] = ptr;
return *ptr;
}
}
};
RiskLimitManager::RiskLimitManager() : me(new PImpl())
{
}
RiskLimitManager::~RiskLimitManager()
{
}
const RiskLimiter& RiskLimitManager::find_limiter(AccountName acctname, orderman::OperatorID opid, orderman::SymbolName symbolname)
{
return me->find_limiter(acctname, opid, symbolname);
}
void RiskLimitManager::on_orderman_ready() { }
void RiskLimitManager::on_orderman_disconnected() { }
void RiskLimitManager::on_order_create(const orderman::OrderState &) { }
void RiskLimitManager::on_order_change(const orderman::OrderState& state)
{
RiskLimiter& lim = me->find_limiter(state.account_name, state.operator_id, me->to_symbolname(state.security_key));
lim.on_order_change(state);
}
}
}