From 8bebbc278d001b337d5b7bf05ba3a52a01ceef50 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Sat, 25 Jan 2025 16:41:30 +0000 Subject: [PATCH] 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. --- .../api/service_helpers/AdminServiceUtils.h | 373 ++++++++++-------- src/lib/md/SettlementRecorder.cpp | 7 +- src/lib/md/SettlementRecorder.h | 5 +- src/lib/orderman/actors/MDSource.h | 3 +- .../orderman/ccapi/CCAPIOrderCallbackMsgs.cpp | 5 +- .../orderman/ccapi/CCAPIOrderCallbackMsgs.h | 14 +- .../gateways/CCAPIExecutionGateway.cpp | 4 +- src/server/sparkd/md/ChannelVolume.cpp | 16 +- .../md/MarketDataAuxiliaryServiceServer.cpp | 6 +- src/server/sparkd/md/VolumeAtPriceState.cpp | 21 +- .../binance_coin_futures_filter_tuple.h | 22 +- .../BinanceUsdsFuturesFilterTuple.h | 42 +- .../sparkd/position/MarginServiceServer.cpp | 8 +- src/server/sparkd/user/AdminServiceServer.cpp | 21 + src/server/sparkd/user/AdminServiceServer.h | 68 ++-- 15 files changed, 336 insertions(+), 279 deletions(-) diff --git a/src/lib/api/service_helpers/AdminServiceUtils.h b/src/lib/api/service_helpers/AdminServiceUtils.h index a5775dcb2..825c51c96 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.h +++ b/src/lib/api/service_helpers/AdminServiceUtils.h @@ -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 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 accounts( - const AdminData &data, bool include_deleted); - static std::vector accounts_mutable( - AdminData &data, bool include_deleted); + static std::vector accounts( + const api::admin::AdminData &data, bool include_deleted); + static std::vector 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 accounts_map(const AdminData &admin_data); + static std::map 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 users( - const AdminData &data, bool include_deleted); - static std::vector 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 users( + const api::admin::AdminData &data, bool include_deleted); + static std::vector 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 + static std::pair 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 &associated_accounts); + std::vector &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 &associated_users); + std::vector &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 &entitlements); + const api::admin::AdminData &admin_data, + std::vector &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 &res); + const api::admin::AdminData &data, + const api::admin::BTSUser &user, + std::vector &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 &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 diff --git a/src/lib/md/SettlementRecorder.cpp b/src/lib/md/SettlementRecorder.cpp index 4b3bb9f89..18c92a829 100644 --- a/src/lib/md/SettlementRecorder.cpp +++ b/src/lib/md/SettlementRecorder.cpp @@ -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 }; diff --git a/src/lib/md/SettlementRecorder.h b/src/lib/md/SettlementRecorder.h index 3ecfa8222..109541716 100644 --- a/src/lib/md/SettlementRecorder.h +++ b/src/lib/md/SettlementRecorder.h @@ -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: diff --git a/src/lib/orderman/actors/MDSource.h b/src/lib/orderman/actors/MDSource.h index ff36ae49f..e719099bc 100644 --- a/src/lib/orderman/actors/MDSource.h +++ b/src/lib/orderman/actors/MDSource.h @@ -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 securities; md::UserSymbol user_symbol; }; diff --git a/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.cpp b/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.cpp index 3f043a58e..01fa7c8fa 100644 --- a/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.cpp +++ b/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.cpp @@ -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 &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 \ No newline at end of file +} // namespace bts::orderman diff --git a/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.h b/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.h index 0fe69bf2d..8939d256f 100644 --- a/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.h +++ b/src/lib/orderman/ccapi/CCAPIOrderCallbackMsgs.h @@ -12,12 +12,10 @@ #include #include -using namespace std; namespace bts::orderman { -using NVMap = std::map; - -const std::string &getm(const NVMap &map, char const *key_name); +const std::string &getm( + const std::map &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 &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 &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 &map) : order_id(getm(map, CCAPI_EM_ORDER_ID)), side( getm(map, CCAPI_EM_ORDER_SIDE) == CCAPI_EM_ORDER_SIDE_BUY diff --git a/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp b/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp index 8356e53d0..63cfdc0c1 100644 --- a/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp +++ b/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp @@ -88,7 +88,7 @@ struct SingleOrderMux { struct InitState { enum class StateType { Start = 0, Securities = 1, Admin = 2 }; - map state_map = { + std::map 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 \ No newline at end of file +} // namespace bts::orderman diff --git a/src/server/sparkd/md/ChannelVolume.cpp b/src/server/sparkd/md/ChannelVolume.cpp index d90d5fe40..5a2f8631a 100644 --- a/src/server/sparkd/md/ChannelVolume.cpp +++ b/src/server/sparkd/md/ChannelVolume.cpp @@ -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(); @@ -52,4 +54,4 @@ bool ChannelVolume::match_update(const SecurityChannel &channel) { } // namespace auxiliary } // namespace md -} // namespace bts \ No newline at end of file +} // namespace bts diff --git a/src/server/sparkd/md/MarketDataAuxiliaryServiceServer.cpp b/src/server/sparkd/md/MarketDataAuxiliaryServiceServer.cpp index 9250b2251..165c3a57b 100644 --- a/src/server/sparkd/md/MarketDataAuxiliaryServiceServer.cpp +++ b/src/server/sparkd/md/MarketDataAuxiliaryServiceServer.cpp @@ -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; diff --git a/src/server/sparkd/md/VolumeAtPriceState.cpp b/src/server/sparkd/md/VolumeAtPriceState.cpp index 66c2e6fac..1a9fe228a 100644 --- a/src/server/sparkd/md/VolumeAtPriceState.cpp +++ b/src/server/sparkd/md/VolumeAtPriceState.cpp @@ -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 diff --git a/src/server/sparkd/md/binance_coin_futures/binance_coin_futures_filter_tuple.h b/src/server/sparkd/md/binance_coin_futures/binance_coin_futures_filter_tuple.h index f71e03a69..475df7145 100644 --- a/src/server/sparkd/md/binance_coin_futures/binance_coin_futures_filter_tuple.h +++ b/src/server/sparkd/md/binance_coin_futures/binance_coin_futures_filter_tuple.h @@ -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; } diff --git a/src/server/sparkd/md/binance_usds_futures/BinanceUsdsFuturesFilterTuple.h b/src/server/sparkd/md/binance_usds_futures/BinanceUsdsFuturesFilterTuple.h index cdc323339..513e74cb7 100644 --- a/src/server/sparkd/md/binance_usds_futures/BinanceUsdsFuturesFilterTuple.h +++ b/src/server/sparkd/md/binance_usds_futures/BinanceUsdsFuturesFilterTuple.h @@ -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; } diff --git a/src/server/sparkd/position/MarginServiceServer.cpp b/src/server/sparkd/position/MarginServiceServer.cpp index db558cfcc..2cda56a2a 100644 --- a/src/server/sparkd/position/MarginServiceServer.cpp +++ b/src/server/sparkd/position/MarginServiceServer.cpp @@ -13,10 +13,10 @@ #include -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 { diff --git a/src/server/sparkd/user/AdminServiceServer.cpp b/src/server/sparkd/user/AdminServiceServer.cpp index 5a6552d81..e55f74d81 100644 --- a/src/server/sparkd/user/AdminServiceServer.cpp +++ b/src/server/sparkd/user/AdminServiceServer.cpp @@ -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()), diff --git a/src/server/sparkd/user/AdminServiceServer.h b/src/server/sparkd/user/AdminServiceServer.h index 09b7ed78d..3df87f457 100644 --- a/src/server/sparkd/user/AdminServiceServer.h +++ b/src/server/sparkd/user/AdminServiceServer.h @@ -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> _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> + _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 &reply) override; + const api::admin::AccountCreateAPIArgument &request, + const api::Response &reply) + override; void update_account( const api::AuthToken &, - const AccountUpdateAPIArgument &request, - const api::Response &reply) override; + const api::admin::AccountUpdateAPIArgument &request, + const api::Response &reply) + override; void create_user( const api::AuthToken &, - const UserCreateAPIArgument &request, - const api::Response &reply) override; + const api::admin::UserCreateAPIArgument &request, + const api::Response &reply) + override; void update_user( const api::AuthToken &, - const UserUpdateAPIArgument &request, - const api::Response &reply) override; + const api::admin::UserUpdateAPIArgument &request, + const api::Response &reply) + override; void get_admin_data( const api::AuthToken &, const bts::api::VoidMessage &request, - const api::Response &reply) override; + const api::Response &reply) override; void get_filtered_admin_data( const api::AuthToken &, const bts::api::admin::FilteredAdminDataRequest &request, - const api::Response &reply) override; + const api::Response &reply) override; void delete_user( const api::AuthToken &, - const IDAPIArgument &request, - const api::Response &reply) override; + const api::admin::IDAPIArgument &request, + const api::Response &reply) + override; void delete_account( const api::AuthToken &, - const IDAPIArgument &request, - const api::Response &reply) override; + const api::admin::IDAPIArgument &request, + const api::Response &reply) + override; void get_order_summary( const api::AuthToken &, const bts::api::VoidMessage &request, - const api::Response &reply) override; + const api::Response &reply) override; void cancel_orders( const api::AuthToken &, - const OrderCancelRequest &request, + const api::admin::OrderCancelRequest &request, const api::Response &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> &agg, - const OrderRecord &order); + std::map< + std::string, + std::map> &agg, + const api::orderman::OrderRecord &order); void _cancel_orders( - const std::vector &accounts, const std::vector &users); + const std::vector &accounts, + const std::vector &users); }; } // namespace admin } // namespace bts