cleanup: Get rid of 'using namespaces'

In headers, this is an objectively bad practice, since the type aliases
leak into dependent code and can cause unexpected naming conflicts. In
source files, it is debatable, but I prefer explicit aliases of the form
'using Foo = Bar'. The intentions are clear, and the resulting code is
naturally resistent to naming conflicts.
This commit is contained in:
John Colvin committed 2025-01-28 19:59:08 +00:00
1 parent 2e6d12c9c1
commit 8bebbc278d
15 files changed
+336 -279

No files matched your search

+201 -172
View File
@@ -9,9 +9,6 @@
namespace bts {
namespace admin {
using namespace bts::api::admin;
using namespace bts::api::orderman;
class AdminServiceUtils {
public:
struct ExchangeSubAccountResolver {
@@ -31,7 +28,7 @@ class AdminServiceUtils {
return is_int_account ? entry.bts_account_name()
: entry.exchange_subaccount();
};
if(sec == nullptr)
if (sec == nullptr)
return nullptr;
for (const auto &u : exch_sub_accounts.accounts()) {
if (get_account(u) == account)
@@ -57,224 +54,247 @@ class AdminServiceUtils {
////////////////////////////////////////////
// finds the max id out of all the existing connections
// (todo: deleted connections)
static uint32_t find_max_connection_id(const AdminData &data);
static uint32_t find_max_connection_id(const api::admin::AdminData &data);
// finds a connection by name and returns a mutable pointer to it
static const ExchangeConnection *find_connection(
const AdminData &data, const std::string &connection_name);
static const api::admin::ExchangeConnection *find_connection(
const api::admin::AdminData &data, const std::string &connection_name);
// finds the presence of an exchange in a connection
static bool has_exchange(
const ExchangeConnection &conn, bts::api::Venue exchange);
const api::admin::ExchangeConnection &conn, api::Venue exchange);
// finds the default connections for an exchange
// in a given account
static const ExchangeConnection *find_default_account_connection(
const AdminData &data,
const BTSAccount &account,
bts::api::Venue exchange);
static const ExchangeConnection *resolve_cme_connection(
const AdminData &data,
const BTSAccount &account,
static const api::admin::ExchangeConnection *find_default_account_connection(
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
api::Venue exchange);
static const api::admin::ExchangeConnection *resolve_cme_connection(
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
const api::Security &sec);
static const ExchangeConnection *resolve_ice_connection(
const AdminData &data,
const BTSAccount &account,
static const api::admin::ExchangeConnection *resolve_ice_connection(
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
const api::Security &sec);
static const ExchangeConnection *resolve_sim_connection(
const AdminData &data,
const BTSAccount &account,
static const api::admin::ExchangeConnection *resolve_sim_connection(
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
const api::Security &sec);
static const ExchangeConnection *resolve_connection(
const AdminData &data,
const BTSAccount &account,
const bts::api::Security &sec);
static const api::admin::ExchangeConnection *resolve_connection(
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
const api::Security &sec);
////////////////////////////////////////////
// connection mutators /////////////////////
////////////////////////////////////////////
// adds a new connection (does not check for name uniqueness)
static ExchangeConnection *add_connection(
AdminData &data, const ExchangeConnection &new_connection);
static api::admin::ExchangeConnection *add_connection(
api::admin::AdminData &data,
const api::admin::ExchangeConnection &new_connection);
// reads the connections from config and fills in the
// admin data (with names only)
static void fill_connections_from_config(AdminData &admin_data);
static void fill_connections_from_config(api::admin::AdminData &admin_data);
////////////////////////////////////////////
// account accessors ///////////////////////
////////////////////////////////////////////
// finds the account from the name and returns
// a mutable pointer to the account
static BTSAccount *find_account(
AdminData &data,
static api::admin::BTSAccount *find_account(
api::admin::AdminData &data,
const std::string &acct_name,
bool include_deleted = false);
static std::map<std::string, uint32_t> get_clearing_account_map(
const AdminData &);
const api::admin::AdminData &);
// finds the account from a clearing account (and its venue)
static BTSAccount const *find_account(
const AdminData &data,
static api::admin::BTSAccount const *find_account(
const api::admin::AdminData &data,
const std::string &clearing_account,
bts::api::Venue);
api::Venue);
// same as above for const pointer
static const BTSAccount *find_account(
const AdminData &data,
static const api::admin::BTSAccount *find_account(
const api::admin::AdminData &data,
const std::string &acct_name,
bool include_deleted = false);
// finds the account from the id and returns
// a mutable pointer to the account
static BTSAccount *find_account(
AdminData &data, uint32_t id, bool include_deleted = false);
static api::admin::BTSAccount *find_account(
api::admin::AdminData &data, uint32_t id, bool include_deleted = false);
// like above but returns a const pointer
static const BTSAccount *find_account(
const AdminData &data, uint32_t id, bool include_deleted = false);
static const api::admin::BTSAccount *find_account(
const api::admin::AdminData &data,
uint32_t id,
bool include_deleted = false);
// this function is an indirection layer for account access
// so deletions are dealt in a more deliberate manner
static std::vector<const BTSAccount *> accounts(
const AdminData &data, bool include_deleted);
static std::vector<BTSAccount *> accounts_mutable(
AdminData &data, bool include_deleted);
static std::vector<const api::admin::BTSAccount *> accounts(
const api::admin::AdminData &data, bool include_deleted);
static std::vector<api::admin::BTSAccount *> accounts_mutable(
api::admin::AdminData &data, bool include_deleted);
// finds the max id amongts all the existing accounts
static uint32_t find_max_acct_id(const AdminData &data);
static uint32_t find_max_acct_id(const api::admin::AdminData &data);
// gets the account data for cme (and goes up the hierarchy
// if needed)
static const CMEAccountData *get_account_cme_data(
const BTSAccount &account, const AdminData &data);
static const ICEAccountData *get_account_ice_data(
const BTSAccount &account, const AdminData &data);
static const SIMAccountData *get_account_sim_data(
const BTSAccount &account, const AdminData &data);
static const api::admin::CMEAccountData *get_account_cme_data(
const api::admin::BTSAccount &account,
const api::admin::AdminData &data);
static const api::admin::ICEAccountData *get_account_ice_data(
const api::admin::BTSAccount &account,
const api::admin::AdminData &data);
static const api::admin::SIMAccountData *get_account_sim_data(
const api::admin::BTSAccount &account,
const api::admin::AdminData &data);
// returns true if an account has a connection
bool static account_has_connection(
const BTSAccount &account, const std::string &connection_name);
const api::admin::BTSAccount &account,
const std::string &connection_name);
// finds the external/clearing account associated
// with an account
static std::string find_account_exchange_account(
const AdminData &data,
const BTSAccount &account,
const api::admin::AdminData &data,
const api::admin::BTSAccount &account,
api::Venue exchange,
AdminServiceOperationResult &out_result);
api::admin::AdminServiceOperationResult &out_result);
// returns a map of the accounts vs their 'is_active'
static std::map<uint32_t, bool> accounts_map(const AdminData &admin_data);
static std::map<uint32_t, bool> accounts_map(
const api::admin::AdminData &admin_data);
// validates that the update to the account is valid
static void validate_account_update(
const AdminData &admin_data,
const BTSAccount &updated_account,
AdminServiceOperationResult &result);
const api::admin::AdminData &admin_data,
const api::admin::BTSAccount &updated_account,
api::admin::AdminServiceOperationResult &result);
// validates that the account exchange changes are valid
// (ex > 12 characters for accounts at CME)
static void validate_account_exchange_data(
const BTSAccount &account, AdminServiceOperationResult &out_result);
static RoutingRecord get_routing_record(
const AdminData &data,
const api::admin::BTSAccount &account,
api::admin::AdminServiceOperationResult &out_result);
static api::orderman::RoutingRecord get_routing_record(
const api::admin::AdminData &data,
const std::string &account_name,
const std::string &user_name,
const bts::api::Security &sec,
AdminServiceOperationResult &out_result);
static RoutingRecord get_routing_record(
const AdminData &data,
const api::Security &sec,
api::admin::AdminServiceOperationResult &out_result);
static api::orderman::RoutingRecord get_routing_record(
const api::admin::AdminData &data,
uint32_t account_id,
uint32_t user_id,
const bts::api::Security &sec,
AdminServiceOperationResult &out_result);
const api::Security &sec,
api::admin::AdminServiceOperationResult &out_result);
////////////////////////////////////////////
// account mutators ////////////////////////
////////////////////////////////////////////
static BTSAccount *create_account(
AdminData &data,
static api::admin::BTSAccount *create_account(
api::admin::AdminData &data,
uint32_t parent_account_id,
const std::string &account_name,
const std::string &description,
bool is_active,
AdminServiceCreateAccountResult &result);
api::admin::AdminServiceCreateAccountResult &result);
// writes over the account data completely
static void update_account(
AdminData &data,
const BTSAccount &updated_account,
AdminServiceOperationResult &result);
api::admin::AdminData &data,
const api::admin::BTSAccount &updated_account,
api::admin::AdminServiceOperationResult &result);
static void delete_account(
AdminData &admin_data,
const IDAPIArgument &id,
AdminServiceOperationResult &result);
api::admin::AdminData &admin_data,
const api::admin::IDAPIArgument &id,
api::admin::AdminServiceOperationResult &result);
static void set_account_exchange_data(
BTSAccount *account, const ExchangeAccountData &exchange_data);
api::admin::BTSAccount *account,
const api::admin::ExchangeAccountData &exchange_data);
// this is not a generally useful function but since
// connection are in config, this cleans up the account's
// connections and syncs it with the list in AdminData
// connections and syncs it with the list in api::admin::AdminData
static void sync_account_connections(
const AdminData &data, BTSAccount &account);
const api::admin::AdminData &data, api::admin::BTSAccount &account);
////////////////////////////////////////////
// group accessors /////////////////////////
////////////////////////////////////////////
// given an id, finds the mutable pointer to a group
static BTSUserGroup *find_group(AdminData &data, uint32_t id);
static api::admin::BTSUserGroup *find_group(
api::admin::AdminData &data, uint32_t id);
// given an id, finds the const pointer to a group
static const BTSUserGroup *const find_group(
const AdminData &data, uint32_t id);
static const api::admin::BTSUserGroup *const find_group(
const api::admin::AdminData &data, uint32_t id);
// given a name, finds the mutable pointer to a group
static BTSUserGroup *find_group(
AdminData &data, const std::string &group_name);
static api::admin::BTSUserGroup *find_group(
api::admin::AdminData &data, const std::string &group_name);
// finds the max id out of all the groups
static uint32_t find_max_group_id(const AdminData &data);
static uint32_t find_max_group_id(const api::admin::AdminData &data);
// travels up the group tree until it finds a populated cme data
static const CMEUserData *get_group_cme_data(
const BTSUserGroup &group, const AdminData &data);
static const ICEUserData *get_group_ice_data(
const BTSUserGroup &group, const AdminData &data);
static const SIMUserData *get_group_sim_data(
const BTSUserGroup &group, const AdminData &data);
static const UserAccountPermissions *const get_group_user_permissions(
const bts::api::admin::AdminData &admin_data, uint32_t group_id);
static const api::admin::CMEUserData *get_group_cme_data(
const api::admin::BTSUserGroup &group,
const api::admin::AdminData &data);
static const api::admin::ICEUserData *get_group_ice_data(
const api::admin::BTSUserGroup &group,
const api::admin::AdminData &data);
static const api::admin::SIMUserData *get_group_sim_data(
const api::admin::BTSUserGroup &group,
const api::admin::AdminData &data);
static const api::admin::UserAccountPermissions *const
get_group_user_permissions(
const api::admin::AdminData &admin_data, uint32_t group_id);
////////////////////////////////////////////
// group mutators/ /////////////////////////
////////////////////////////////////////////
static BTSUserGroup *create_group(
AdminData &data,
static api::admin::BTSUserGroup *create_group(
api::admin::AdminData &data,
uint32_t parent_group_id,
const std::string &group_name,
AdminServiceOperationResult &result);
api::admin::AdminServiceOperationResult &result);
////////////////////////////////////////////
// user accessors //////////////////////////
////////////////////////////////////////////
static BTSUser *find_user(
AdminData &data,
static api::admin::BTSUser *find_user(
api::admin::AdminData &data,
const std::string &user_name,
bool include_deleted = false);
static const BTSUser *find_user(
const AdminData &data,
static const api::admin::BTSUser *find_user(
const api::admin::AdminData &data,
const std::string &user_name,
bool include_deleted = false);
static BTSUser *find_user(
AdminData &data, uint32_t id, bool include_deleted = false);
static const BTSUser *const find_user(
const AdminData &data, uint32_t id, bool include_deleted = false);
static std::vector<const BTSUser *> users(
const AdminData &data, bool include_deleted);
static std::vector<BTSUser *> users_mutable(
AdminData &data, bool include_deleted);
static uint32_t find_max_user_id(const AdminData &data);
static const CMEUserData *get_user_cme_data(
const BTSUser &user, const AdminData &data);
static const ICEUserData *get_user_ice_data(
const BTSUser &user, const AdminData &data);
static const SIMUserData *get_user_sim_data(
const BTSUser &user, const AdminData &data);
static api::admin::BTSUser *find_user(
api::admin::AdminData &data, uint32_t id, bool include_deleted = false);
static const api::admin::BTSUser *const find_user(
const api::admin::AdminData &data,
uint32_t id,
bool include_deleted = false);
static std::vector<const api::admin::BTSUser *> users(
const api::admin::AdminData &data, bool include_deleted);
static std::vector<api::admin::BTSUser *> users_mutable(
api::admin::AdminData &data, bool include_deleted);
static uint32_t find_max_user_id(const api::admin::AdminData &data);
static const api::admin::CMEUserData *get_user_cme_data(
const api::admin::BTSUser &user, const api::admin::AdminData &data);
static const api::admin::ICEUserData *get_user_ice_data(
const api::admin::BTSUser &user, const api::admin::AdminData &data);
static const api::admin::SIMUserData *get_user_sim_data(
const api::admin::BTSUser &user, const api::admin::AdminData &data);
// finds the "exchange user" (ex: "operator_id" at CME or "authorized_trader"
// at ICE) for a user
static std::string find_user_exchange_id(
const AdminData &data,
const BTSUser &user,
const api::admin::AdminData &data,
const api::admin::BTSUser &user,
api::Venue exchange,
AdminServiceOperationResult &out_result);
api::admin::AdminServiceOperationResult &out_result);
// i. uses the exchange and exchange_user to reverse lookup the user(s)
// ii. uses the exchange, connection and exchange_account to reverse lookup
// the account(s) iii. finds the first account from ii that a user from i is
// authorized to trade
static std::string find_user_company_id(
const AdminData &data,
const BTSUser &user,
const api::admin::AdminData &data,
const api::admin::BTSUser &user,
api::Venue exchange,
AdminServiceOperationResult &out_result);
api::admin::AdminServiceOperationResult &out_result);
static std::pair<const BTSAccount *, const BTSUser *>
static std::pair<const api::admin::BTSAccount *, const api::admin::BTSUser *>
find_user_account_matches(
const AdminData &admin_data,
const api::admin::AdminData &admin_data,
const std::string &connection,
const std::string &exchange_account,
const std::string &exchange_user,
@@ -282,100 +302,108 @@ class AdminServiceUtils {
// for a given user finds the account permissions (if permissions are
// derived from the group, it traverses the group hierarcy to find the
// correct permissions.
static const UserAccountPermissions *get_user_permissions(
const AdminData &admin_data, uint32_t user_id);
static const api::admin::UserAccountPermissions *get_user_permissions(
const api::admin::AdminData &admin_data, uint32_t user_id);
// for a given user, fills in the associated_accounts ref arg
// with the accounts the user has permission to trade in
static void find_user_trading_accounts(
const AdminData &admin_data,
const api::admin::AdminData &admin_data,
uint32_t user_id,
std::vector<const BTSAccount *> &associated_accounts);
std::vector<const api::admin::BTSAccount *> &associated_accounts);
// for a given account, fills in the associated_users ref arg
// with the users that can trade into the account
static void find_users_for_trading_account(
const AdminData &admin_data,
const api::admin::AdminData &admin_data,
uint32_t account_id,
std::vector<const BTSUser *> &associated_users);
std::vector<const api::admin::BTSUser *> &associated_users);
// validates that changes in user data satisfy all the
// constraints
static void validate_user_update(
const AdminData &admin_data,
const BTSUser &updated_user,
AdminServiceOperationResult &result);
const api::admin::AdminData &admin_data,
const api::admin::BTSUser &updated_user,
api::admin::AdminServiceOperationResult &result);
// vaidates the exchange part of user data updates
static void validate_user_exchange_data(
const BTSUser &updated_user, AdminServiceOperationResult &out_result);
const api::admin::BTSUser &updated_user,
api::admin::AdminServiceOperationResult &out_result);
static void get_md_entitlement_report(
const AdminData &admin_data,
std::vector<MDEntitlementReportUnit> &entitlements);
const api::admin::AdminData &admin_data,
std::vector<api::admin::MDEntitlementReportUnit> &entitlements);
// Gets a reporting unit out of CMEMicData
static MDEntitlementReportUnit get_cme_md_entitlement_unit(
const BTSUser &user, const CMEMicData &cme_mic_data);
static MDEntitlementReportUnit get_ice_md_entitlement_unit(
const BTSUser &user, const ICEMicData &ice_mic_data);
static api::admin::MDEntitlementReportUnit get_cme_md_entitlement_unit(
const api::admin::BTSUser &user,
const api::admin::CMEMicData &cme_mic_data);
static api::admin::MDEntitlementReportUnit get_ice_md_entitlement_unit(
const api::admin::BTSUser &user,
const api::admin::ICEMicData &ice_mic_data);
static void get_user_symbol_permissions(
const AdminData &data,
const BTSUser &user,
std::vector<UserSymbolMDPermissionUnit> &res);
const api::admin::AdminData &data,
const api::admin::BTSUser &user,
std::vector<api::admin::UserSymbolMDPermissionUnit> &res);
////////////////////////////////////////////
// user mutators ///////////////////////////
////////////////////////////////////////////
static BTSUser *create_user(
AdminData &data,
static api::admin::BTSUser *create_user(
api::admin::AdminData &data,
uint32_t parent_group_id,
const std::string &name,
const std::string &password,
const std::string &full_name,
const std::string &company,
bool is_active,
const LicenseData &license_data,
const LicenseEntitlements &license_entitlements,
AdminServiceCreateEntityResult &result);
static BTSUser *update_user(
AdminData &admin_data,
const BTSUser &updated_user,
AdminServiceOperationResult &result);
const api::admin::LicenseData &license_data,
const api::admin::LicenseEntitlements &license_entitlements,
api::admin::AdminServiceCreateEntityResult &result);
static api::admin::BTSUser *update_user(
api::admin::AdminData &admin_data,
const api::admin::BTSUser &updated_user,
api::admin::AdminServiceOperationResult &result);
static void delete_user(
AdminData &admin_data,
const IDAPIArgument &id,
AdminServiceOperationResult &result);
api::admin::AdminData &admin_data,
const api::admin::IDAPIArgument &id,
api::admin::AdminServiceOperationResult &result);
static void set_user_exchange_data(
BTSUser *user, const ExchangeUserData &exchange_user_data);
static void clear_user_accounts(BTSUser *user);
api::admin::BTSUser *user,
const api::admin::ExchangeUserData &exchange_user_data);
static void clear_user_accounts(api::admin::BTSUser *user);
static void set_user_accounts(
BTSUser *user, const UserAccountPermissions &user_account_permissions);
api::admin::BTSUser *user,
const api::admin::UserAccountPermissions &user_account_permissions);
////////////////////////////////////////////
// risk limits //////////////////////////////
////////////////////////////////////////////
// sorting function used by sort_limits to
// sort SecurityScope's
static bool _sort_security_scopes(
const SecurityScope &a, const SecurityScope &b);
const api::admin::SecurityScope &a, const api::admin::SecurityScope &b);
// sorting function used by sort_limits to
// sort ProductScope's
static bool _sort_product_scopes(
const ProductScope &a, const ProductScope &);
const api::admin::ProductScope &a, const api::admin::ProductScope &);
// this sorts the rules such that the most
// specific ones are at the top. this makes it
// easier to match rules with securities/products
static void sort_limits(BTSAccount &account);
// creates a copy of AdminData with sorted rules
static AdminData sort_limits(const AdminData &admin_data);
static void sort_limits(api::admin::BTSAccount &account);
// creates a copy of api::admin::AdminData with sorted rules
static api::admin::AdminData sort_limits(
const api::admin::AdminData &admin_data);
// find the clip size for a security, account
static const uint32_t find_account_security_clip_size(
const BTSAccount &account, const api::Security &security);
const api::admin::BTSAccount &account, const api::Security &security);
// find the position limit for an account, security
static const AccountSecurityPositionLimitUnit *
static const api::admin::AccountSecurityPositionLimitUnit *
find_account_security_position_limit(
const BTSAccount &account, const api::Security &security);
const api::admin::BTSAccount &account, const api::Security &security);
// find the position limit for an account, product
static const AccountProductPositionLimitUnit *
static const api::admin::AccountProductPositionLimitUnit *
find_account_product_position_limit(
const BTSAccount &account, const api::Product &product);
const api::admin::BTSAccount &account, const api::Product &product);
static bool match_security_scope(
const SecurityScope &scope, const api::Security &security);
const api::admin::SecurityScope &scope, const api::Security &security);
static bool match_product_scope(
const ProductScope &scope, const api::Product &product);
const api::admin::ProductScope &scope, const api::Product &product);
static bool match_product(
const api::Security &security, const api::Product &product);
static bool _match_limit_rule_symbol(
@@ -386,13 +414,14 @@ class AdminServiceUtils {
////////////////////////////////////////////
static bool has_id(uint32_t id);
static bool is_symbol_set(const std::string &symbol);
static void bootstrap_data(bts::api::admin::AdminData &data);
static void bootstrap_data(api::admin::AdminData &data);
static void get_spread_prod_qty(
const api::Security &s,
std::map<std::string, double> &out_map,
double mult = 1.0);
// returns true if this spread effects the position of any outrights
static bool residual_pos_spread(const api::Security &s);
};
};
} // namespace admin
} // namespace bts
+5 -2
View File
@@ -13,10 +13,13 @@
namespace bts {
namespace co2 {
using bts::md::INT_NAN;
using bts::md::IntPrice;
using bts::md::invalid_security_key;
using bts::md::MDProducerHandle;
using bts::md::security_key;
using datetime::Date;
using std::string;
using std::unique_ptr;
using namespace utils;
enum WorkType { SNAPSHOT, UPDATE };
+2 -3
View File
@@ -7,7 +7,6 @@
namespace bts {
namespace co2 {
using namespace md;
struct SettlementRecorderImpl;
class SettlementRecorder {
@@ -17,9 +16,9 @@ class SettlementRecorder {
// Put settlement update in a queue
// in do_work() drain queue and update settlement 'depth'
void restore_settlement(MDProducerHandle handle);
void restore_settlement(md::MDProducerHandle handle);
void add_settlement(
MDProducerHandle handle, IntPrice price, datetime::Date date);
md::MDProducerHandle handle, md::IntPrice price, datetime::Date date);
void do_work();
private:
+1 -2
View File
@@ -5,7 +5,6 @@
#include "lib/md/IntPrice.h"
#include "lib/md/MDConsumer.h"
#include "lib/md/MDConsumerHandle.h"
#include "lib/md/cme/MDP3Utils.h"
#include "lib/mercury/actors/Actor.h"
#include "lib/mercury/actors/IPollableActor.h"
#include "lib/mercury/events/TimerEvent.h"
@@ -361,7 +360,7 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor {
struct ChannelRecord {
int64_t cursor;
co2::MDConsumerChannel channel;
md::MDConsumerChannel channel;
boost::container::small_vector<TickerUpdateEvent, 5> securities;
md::UserSymbol user_symbol;
};
@@ -4,7 +4,8 @@
namespace bts::orderman {
const std::string &getm(const NVMap &map, char const *key_name) {
const std::string &getm(
const std::map<std::string, std::string> &map, char const *key_name) {
auto it = map.find(key_name);
bts_assert_msg(
it != map.end(), "Could not find key_name" + std::string(key_name));
@@ -59,4 +60,4 @@ std::ostream &operator<<(
return out;
}
} // namespace bts::orderman
} // namespace bts::orderman
@@ -12,12 +12,10 @@
#include <optional>
#include <string>
using namespace std;
namespace bts::orderman {
using NVMap = std::map<std::string, std::string>;
const std::string &getm(const NVMap &map, char const *key_name);
const std::string &getm(
const std::map<std::string, std::string> &map, char const *key_name);
bts::api::orderman::OrderStatus convert_ccapi_status(const std::string &status);
// 1.
@@ -59,7 +57,9 @@ struct CCAPICreateOrderMsg {
double cumm_filled_qty;
bts::api::orderman::OrderStatus status;
std::string corr_id;
CCAPICreateOrderMsg(const NVMap &map, const std::string &corr_id)
CCAPICreateOrderMsg(
const std::map<std::string, std::string> &map,
const std::string &corr_id)
: order_id(getm(map, CCAPI_EM_ORDER_ID)),
instrument(getm(map, CCAPI_INSTRUMENT)),
side(
@@ -152,7 +152,7 @@ struct CCAPIOrderUpdateMsg {
double cumm_filled_price;
double cumm_filled_qty;
api::orderman::OrderStatus status;
CCAPIOrderUpdateMsg(const NVMap &map)
CCAPIOrderUpdateMsg(const std::map<std::string, std::string> &map)
: order_id(getm(map, CCAPI_EM_ORDER_ID)),
side(
getm(map, CCAPI_EM_ORDER_SIDE) == CCAPI_EM_ORDER_SIDE_BUY
@@ -204,7 +204,7 @@ struct CCAPITradeMsg {
double last_exec_price;
double last_exec_qty;
std::string trade_id;
CCAPITradeMsg(const NVMap &map)
CCAPITradeMsg(const std::map<std::string, std::string> &map)
: order_id(getm(map, CCAPI_EM_ORDER_ID)),
side(
getm(map, CCAPI_EM_ORDER_SIDE) == CCAPI_EM_ORDER_SIDE_BUY
@@ -88,7 +88,7 @@ struct SingleOrderMux {
struct InitState {
enum class StateType { Start = 0, Securities = 1, Admin = 2 };
map<StateType, bool> state_map = {
std::map<StateType, bool> state_map = {
{StateType::Start, false},
{StateType::Securities, false},
{StateType::Admin, false}};
@@ -492,4 +492,4 @@ SingleOrderMux *CCAPIExecutionGateway::_find_mux_from_orderkey(OrderKey key) {
return _find_mux(it->second.routing_record);
}
} // namespace bts::orderman
} // namespace bts::orderman
+9 -7
View File
@@ -1,18 +1,20 @@
#include "ChannelVolume.h"
#include "lib/api/services/MarketDataRelay.pb.h"
#include "lib/md/PriceSize.h"
#include "lib/md/IntPrice.h"
#include "lib/md/protos/co2.pb.h"
namespace bts {
namespace md {
namespace auxiliary {
using namespace bts::co2;
using namespace bts::api::md::auxiliary;
using bts::api::md::auxiliary::VolumeAtPriceLevel;
using bts::co2::AggressorSide;
using bts::co2::SecurityChannel;
using bts::co2::TradeMessage;
ChannelVolume::ChannelVolume(SecurityChannel *channel) : _channel(channel) {}
const VolumeAtPriceLevel &
ChannelVolume::add_trade(const TradeMessage &m, int &record_id) {
const VolumeAtPriceLevel &ChannelVolume::add_trade(
const TradeMessage &m, int &record_id) {
auto price_map_it = _sec_map.find(m.key());
if (price_map_it == _sec_map.end()) {
_sec_map[m.key()] = std::unordered_map<uint64_t, VolumeAtPriceLevel>();
@@ -52,4 +54,4 @@ bool ChannelVolume::match_update(const SecurityChannel &channel) {
} // namespace auxiliary
} // namespace md
} // namespace bts
} // namespace bts
@@ -2,20 +2,18 @@
#include "VolumeAtPriceState.h"
#include "lib/api/public/ServiceContext.h"
#include "lib/api/services/MarketDataRelay.client.pb.h"
#include "lib/api/services/MarketDataRelay.pb.h"
#include "lib/config/config.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/logging/logging.h"
#include "lib/utils/Dispatcher.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/bts_chrono.h"
namespace bts {
namespace md {
namespace auxiliary {
using namespace bts::co2;
using namespace bts::api::md::auxiliary;
using bts::co2::MarketDataRelay;
using bts::co2::MDReply;
struct MarketDataAuxiliaryServiceServer::PImpl {
bool vap_enabled;
+11 -10
View File
@@ -1,13 +1,16 @@
#include "VolumeAtPriceState.h"
#include "lib/api/services/MarketDataAuxiliaryService.server.pb.h"
#include "lib/md/SymbolLoader.h"
namespace bts {
namespace md {
namespace auxiliary {
using namespace bts::api::md::auxiliary;
using namespace bts::co2;
using namespace std;
using bts::api::md::auxiliary::MarketDataAuxiliaryServiceBase;
using bts::co2::ChannelReply;
using bts::co2::MDRequest;
using bts::co2::SecurityChannel;
using bts::co2::TradeMessage;
VolumeAtPriceState::VolumeAtPriceState()
: _channels(), _md_req(), _record_id(0) {
@@ -24,8 +27,8 @@ VolumeAtPriceState::VolumeAtPriceState()
}
}
ChannelVolume &
VolumeAtPriceState::_update_or_add(const SecurityChannel &channel) {
ChannelVolume &VolumeAtPriceState::_update_or_add(
const SecurityChannel &channel) {
for (auto &v : _channels)
if (v.match_update(channel))
return v;
@@ -42,17 +45,15 @@ void VolumeAtPriceState::on_new_trades(
uint32_t &total_unique_levels) {
ChannelVolume &channel_vol = _update_or_add(reply.channel());
for (const TradeMessage &t : reply.trade_log()) {
const VolumeAtPriceLevel &sec_level_vol =
channel_vol.add_trade(t, _record_id);
const auto &sec_level_vol = channel_vol.add_trade(t, _record_id);
publisher.add_or_update(sec_level_vol);
n_trades++;
}
total_unique_levels = _record_id;
}
const bts::co2::MDRequest &VolumeAtPriceState::md_req() const {
return _md_req;
}
const MDRequest &VolumeAtPriceState::md_req() const { return _md_req; }
} // namespace auxiliary
} // namespace md
} // namespace bts
@@ -14,15 +14,13 @@
namespace bts::md::binance_coin_futures {
using namespace bts::md::binance;
class BinanceCoinFuturesFilterTuple {
public:
BinanceLotSizeFilter lot_size;
BinanceMarketLotSizeFilter market_lot_size;
binance::BinanceLotSizeFilter lot_size;
binance::BinanceMarketLotSizeFilter market_lot_size;
BinanceCoinFuturesMaxNumOrdersFilter max_num_orders;
BinanceCoinFuturesPercentPriceFilter percent_price;
BinancePriceFilter price;
binance::BinancePriceFilter price;
};
void from_json(const nlohmann::json &j, BinanceCoinFuturesFilterTuple &f);
@@ -39,27 +37,27 @@ inline void from_json(
const nlohmann::json &j, BinanceCoinFuturesFilterTuple &f) {
for (const auto &el : j) {
io::JsonReader jr{&el};
BinanceFilterType filter_type;
binance::BinanceFilterType filter_type;
if (!jr.read("filterType", filter_type)) {
continue;
}
switch (filter_type.value) {
case BinanceFilterType::LOT_SIZE:
case binance::BinanceFilterType::LOT_SIZE:
jr.read(f.lot_size);
break;
case BinanceFilterType::MARKET_LOT_SIZE:
case binance::BinanceFilterType::MARKET_LOT_SIZE:
jr.read(f.market_lot_size);
break;
case BinanceFilterType::MAX_NUM_ORDERS:
case binance::BinanceFilterType::MAX_NUM_ORDERS:
jr.read(f.max_num_orders);
break;
case BinanceFilterType::PERCENT_PRICE:
case binance::BinanceFilterType::PERCENT_PRICE:
jr.read(f.percent_price);
break;
case BinanceFilterType::PRICE_FILTER:
case binance::BinanceFilterType::PRICE_FILTER:
jr.read(f.price);
break;
case BinanceFilterType::NONE:
case binance::BinanceFilterType::NONE:
default:
continue;
}
@@ -20,21 +20,19 @@
namespace bts::md::binance_usds_futures {
using namespace bts::md::binance;
class BinanceUsdsFuturesFilterTuple {
public:
BinanceLotSizeFilter lot_size;
BinanceMarketLotSizeFilter market_lot_size;
binance::BinanceLotSizeFilter lot_size;
binance::BinanceMarketLotSizeFilter market_lot_size;
BinanceUsdsFuturesMaxNumAlgoOrdersFilter max_num_algo_orders;
BinanceUsdsFuturesMaxNumOrdersFilter max_num_orders;
BinanceMaxPositionFilter max_position;
BinanceIcebergPartsFilter iceberg_parts;
binance::BinanceMaxPositionFilter max_position;
binance::BinanceIcebergPartsFilter iceberg_parts;
BinanceUsdsFuturesMinNotionalFilter min_notional;
BinanceUsdsFuturesPercentPriceFilter percent_price;
BinancePercentPriceBySideFilter percent_price_by_side;
BinancePriceFilter price;
BinanceTrailingDeltaFilter trailing_delta;
binance::BinancePercentPriceBySideFilter percent_price_by_side;
binance::BinancePriceFilter price;
binance::BinanceTrailingDeltaFilter trailing_delta;
};
void from_json(const nlohmann::json &j, BinanceUsdsFuturesFilterTuple &f);
@@ -51,45 +49,45 @@ inline void from_json(
const nlohmann::json &j, BinanceUsdsFuturesFilterTuple &f) {
for (const auto &el : j) {
io::JsonReader jr{&el};
BinanceFilterType filter_type;
binance::BinanceFilterType filter_type;
if (!jr.read("filterType", filter_type)) {
continue;
}
switch (filter_type.value) {
case BinanceFilterType::ICEBERG_PARTS:
case binance::BinanceFilterType::ICEBERG_PARTS:
jr.read(f.iceberg_parts);
break;
case BinanceFilterType::LOT_SIZE:
case binance::BinanceFilterType::LOT_SIZE:
jr.read(f.lot_size);
break;
case BinanceFilterType::MARKET_LOT_SIZE:
case binance::BinanceFilterType::MARKET_LOT_SIZE:
jr.read(f.market_lot_size);
break;
case BinanceFilterType::MAX_NUM_ALGO_ORDERS:
case binance::BinanceFilterType::MAX_NUM_ALGO_ORDERS:
jr.read(f.max_num_algo_orders);
break;
case BinanceFilterType::MAX_NUM_ORDERS:
case binance::BinanceFilterType::MAX_NUM_ORDERS:
jr.read(f.max_num_orders);
break;
case BinanceFilterType::MAX_POSITION:
case binance::BinanceFilterType::MAX_POSITION:
jr.read(f.max_position);
break;
case BinanceFilterType::MIN_NOTIONAL:
case binance::BinanceFilterType::MIN_NOTIONAL:
jr.read(f.min_notional);
break;
case BinanceFilterType::PERCENT_PRICE:
case binance::BinanceFilterType::PERCENT_PRICE:
jr.read(f.percent_price);
break;
case BinanceFilterType::PERCENT_PRICE_BY_SIDE:
case binance::BinanceFilterType::PERCENT_PRICE_BY_SIDE:
jr.read(f.percent_price_by_side);
break;
case BinanceFilterType::PRICE_FILTER:
case binance::BinanceFilterType::PRICE_FILTER:
jr.read(f.price);
break;
case BinanceFilterType::TRAILING_DELTA:
case binance::BinanceFilterType::TRAILING_DELTA:
jr.read(f.trailing_delta);
break;
case BinanceFilterType::NONE:
case binance::BinanceFilterType::NONE:
default:
continue;
}
@@ -13,10 +13,10 @@
#include <utility>
using namespace bts::api::orderman;
using namespace bts::api::position;
using namespace bts::admin;
using namespace std;
using bts::admin::AdminServiceUtils;
using bts::api::admin::AccountUpdateAPIArgument;
using bts::api::position::AccountPNL;
using bts::api::position::ExcessLiquidityReport;
using bts::api::position::MarginResult;
namespace bts {
@@ -16,6 +16,27 @@
namespace bts {
namespace admin {
using bts::api::admin::AccountCreateAPIArgument;
using bts::api::admin::AccountUpdateAPIArgument;
using bts::api::admin::AdminData;
using bts::api::admin::AdminServiceCreateAccountResult;
using bts::api::admin::AdminServiceCreateEntityResult;
using bts::api::admin::AdminServiceOperationResult;
using bts::api::admin::BTSUser;
using bts::api::admin::IDAPIArgument;
using bts::api::admin::MDEntitlementReportUnit;
using bts::api::admin::OrderCancelRequest;
using bts::api::admin::OrdersSummary;
using bts::api::admin::OrdersSummaryUnit;
using bts::api::admin::UserAccountPermissionUnit;
using bts::api::admin::UserCreateAPIArgument;
using bts::api::admin::UserUpdateAPIArgument;
using bts::api::orderman::Cancel;
using bts::api::orderman::OrderRecord;
using std::map;
using std::string;
using std::vector;
AdminServiceServer::AdminServiceServer(bts::api::ServiceContext &context)
: bts::api::admin::AuthenticatedAdminServiceBase(context), _db(), _state(),
_publisher(make_admin_data_stateful_publisher()),
+38 -30
View File
@@ -11,19 +11,18 @@
namespace bts {
namespace admin {
using namespace bts::api::orderman;
using namespace bts::api::admin;
using namespace std;
class AdminServiceServer : public api::admin::AuthenticatedAdminServiceBase {
private:
admin::AdminServiceDB _db;
bts::api::admin::AdminData _state;
AdminServiceBase::Admin_dataStatefulPublisher _publisher;
AdminServiceBase::Md_entitlement_dataStatefulPublisher _md_entit_publisher;
AdminServiceBase::Md_permissions_dataStatefulPublisher _md_perm_publisher;
OrderService _order_service;
map<uint32_t, shared_ptr<const OrderRecord>> _order_map;
AdminServiceDB _db;
api::admin::AdminData _state;
api::admin::AdminServiceBase::Admin_dataStatefulPublisher _publisher;
api::admin::AdminServiceBase::Md_entitlement_dataStatefulPublisher
_md_entit_publisher;
api::admin::AdminServiceBase::Md_permissions_dataStatefulPublisher
_md_perm_publisher;
api::orderman::OrderService _order_service;
std::map<std::uint32_t, std::shared_ptr<const api::orderman::OrderRecord>>
_order_map;
public:
// BTS_NO_COPY(UserModelServiceServer);
@@ -32,52 +31,58 @@ class AdminServiceServer : public api::admin::AuthenticatedAdminServiceBase {
void create_account(
const api::AuthToken &,
const AccountCreateAPIArgument &request,
const api::Response<AdminServiceCreateAccountResult> &reply) override;
const api::admin::AccountCreateAPIArgument &request,
const api::Response<api::admin::AdminServiceCreateAccountResult> &reply)
override;
void update_account(
const api::AuthToken &,
const AccountUpdateAPIArgument &request,
const api::Response<AdminServiceOperationResult> &reply) override;
const api::admin::AccountUpdateAPIArgument &request,
const api::Response<api::admin::AdminServiceOperationResult> &reply)
override;
void create_user(
const api::AuthToken &,
const UserCreateAPIArgument &request,
const api::Response<AdminServiceCreateEntityResult> &reply) override;
const api::admin::UserCreateAPIArgument &request,
const api::Response<api::admin::AdminServiceCreateEntityResult> &reply)
override;
void update_user(
const api::AuthToken &,
const UserUpdateAPIArgument &request,
const api::Response<AdminServiceOperationResult> &reply) override;
const api::admin::UserUpdateAPIArgument &request,
const api::Response<api::admin::AdminServiceOperationResult> &reply)
override;
void get_admin_data(
const api::AuthToken &,
const bts::api::VoidMessage &request,
const api::Response<AdminData> &reply) override;
const api::Response<api::admin::AdminData> &reply) override;
void get_filtered_admin_data(
const api::AuthToken &,
const bts::api::admin::FilteredAdminDataRequest &request,
const api::Response<AdminData> &reply) override;
const api::Response<api::admin::AdminData> &reply) override;
void delete_user(
const api::AuthToken &,
const IDAPIArgument &request,
const api::Response<AdminServiceOperationResult> &reply) override;
const api::admin::IDAPIArgument &request,
const api::Response<api::admin::AdminServiceOperationResult> &reply)
override;
void delete_account(
const api::AuthToken &,
const IDAPIArgument &request,
const api::Response<AdminServiceOperationResult> &reply) override;
const api::admin::IDAPIArgument &request,
const api::Response<api::admin::AdminServiceOperationResult> &reply)
override;
void get_order_summary(
const api::AuthToken &,
const bts::api::VoidMessage &request,
const api::Response<OrdersSummary> &reply) override;
const api::Response<api::admin::OrdersSummary> &reply) override;
void cancel_orders(
const api::AuthToken &,
const OrderCancelRequest &request,
const api::admin::OrderCancelRequest &request,
const api::Response<bts::api::VoidMessage> &reply) override;
private:
@@ -90,10 +95,13 @@ class AdminServiceServer : public api::admin::AuthenticatedAdminServiceBase {
void _publish_md_entitlements();
void _publish_md_permissions();
void _add_live_order(
map<string, map<string, OrdersSummaryUnit>> &agg,
const OrderRecord &order);
std::map<
std::string,
std::map<std::string, api::admin::OrdersSummaryUnit>> &agg,
const api::orderman::OrderRecord &order);
void _cancel_orders(
const std::vector<string> &accounts, const std::vector<string> &users);
const std::vector<std::string> &accounts,
const std::vector<std::string> &users);
};
} // namespace admin
} // namespace bts