#pragma once #include "UserSymbol.h" #include "common.h" #include "lib/config/config.h" #include "lib/config/protos/symbols.pb.h" #include "lib/domain/SecurityCriteria.h" #include "lib/domain_model/Security.pb.h" #include #include #include namespace bts::md { // Macro aliases for verbose types/fns. Be sure to undef at end of file. #define SEC_TYPE(t) bts::api::SECURITYTYPE_##t #define VENUE(v) bts::api::VENUE_##v class SymbolLoader { public: static std::set load( const bts::domain::SecurityCriteria &filter = {}); static std::size_t load( std::set &result, const bts::domain::SecurityCriteria &filter = {}); static std::size_t load( std::vector &result, const bts::domain::SecurityCriteria &filter = {}); private: SymbolLoader(const SymbolLoader &); SymbolLoader &operator=(const SymbolLoader &); static constexpr bool venue_has_synths(Venue venue); static void add_symbols( const google::protobuf::RepeatedPtrField &symbols, Venue exchange, SecurityType type, std::set &result); static bool parse_venue(const std::string &str, bts::md::Venue *venue); }; ////////////////////////////////////////////////// // Definition ////////////////////////////////////////////////// constexpr bool SymbolLoader::venue_has_synths(Venue venue) { switch (venue) { case VENUE(SIM): case VENUE(SIMICE): case VENUE(ICE): case VENUE(GLBX): case VENUE(BINANCE): case VENUE(BINANCE_USDS_FUTURES): case VENUE(DERIBIT): case VENUE(OKX): return true; default: return false; } } inline void SymbolLoader::add_symbols( const google::protobuf::RepeatedPtrField &symbols, Venue exchange, SecurityType type, std::set &result) { for (const auto &s : symbols) { UserSymbol u(s, exchange, type); result.insert(u); } } inline std::set SymbolLoader::load( const bts::domain::SecurityCriteria &filter) { std::set result; load(result, filter); return result; } inline std::size_t SymbolLoader::load( std::set &result, const bts::domain::SecurityCriteria &filter) { const auto orig_sz = result.size(); const auto &cfg = config::get(); const bool include_all = !filter.is_defined(); for (const auto &vcfg : cfg.venues()) { Venue venue; if (!parse_venue(vcfg.name(), &venue)) { LOG(md, Error, "Unable to load symbols for unknown venue '{}'", vcfg.name()); continue; } if (include_all || filter.includes(venue, SEC_TYPE(SPOT))) { add_symbols(vcfg.spot(), venue, SEC_TYPE(SPOT), result); } if (include_all || filter.includes(venue, SEC_TYPE(FUTURE))) { add_symbols(vcfg.future(), venue, SEC_TYPE(FUTURE), result); } if (include_all || filter.includes(venue, SEC_TYPE(OPTION))) { add_symbols(vcfg.option(), venue, SEC_TYPE(OPTION), result); } if (include_all || filter.includes(venue, SEC_TYPE(SPREAD))) { add_symbols(vcfg.spread(), venue, SEC_TYPE(SPREAD), result); } if (include_all || (venue_has_synths(venue) && filter.includes(venue, SEC_TYPE(SYNTHETIC)))) { add_symbols(vcfg.spot(), VENUE(BTS), SEC_TYPE(SYNTHETIC), result); add_symbols(vcfg.future(), VENUE(BTS), SEC_TYPE(SYNTHETIC), result); add_symbols(vcfg.option(), VENUE(BTS), SEC_TYPE(SYNTHETIC), result); add_symbols(vcfg.spread(), VENUE(BTS), SEC_TYPE(SYNTHETIC), result); } } return result.size() - orig_sz; } inline std::size_t SymbolLoader::load( std::vector &result, const bts::domain::SecurityCriteria &filter) { std::set result_set; auto n_loaded = load(result_set, filter); result.insert(result.end(), result_set.begin(), result_set.end()); return n_loaded; } inline bool SymbolLoader::parse_venue( const std::string &str, bts::md::Venue *venue) { if (Venue_Parse(str, venue)) { return true; } if (str.rfind("VENUE_", 0) == 0) { if (Venue_Parse(std::string{"VENUE_"} + str, venue)) { return true; } } return false; } #undef SEC_TYPE #undef VENUE } // namespace bts::md