147 lines
4.3 KiB
C++
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
|