Files
spark/src/lib/md/SymbolLoader.h
T

147 lines
4.3 KiB
C++

#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 <set>
#include <string>
#include <vector>
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<UserSymbol> load(
const bts::domain::SecurityCriteria &filter = {});
static std::size_t load(
std::set<UserSymbol> &result,
const bts::domain::SecurityCriteria &filter = {});
static std::size_t load(
std::vector<UserSymbol> &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<std::string> &symbols,
Venue exchange,
SecurityType type,
std::set<UserSymbol> &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<std::string> &symbols,
Venue exchange,
SecurityType type,
std::set<UserSymbol> &result) {
for (const auto &s : symbols) {
UserSymbol u(s, exchange, type);
result.insert(u);
}
}
inline std::set<UserSymbol> SymbolLoader::load(
const bts::domain::SecurityCriteria &filter) {
std::set<UserSymbol> result;
load(result, filter);
return result;
}
inline std::size_t SymbolLoader::load(
std::set<UserSymbol> &result, const bts::domain::SecurityCriteria &filter) {
const auto orig_sz = result.size();
const auto &cfg = config::get<config::system_symbols::Symbols>();
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<UserSymbol> &result,
const bts::domain::SecurityCriteria &filter) {
std::set<UserSymbol> 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