Files
spark/src/lib/md/SymbolLoader.h
T
John Colvin b53d9d7d4c refactor: Remove 'Platform' (md source) config
Good riddance. Improper 'PlatformMap' config was often the reason market
data mysteriously wouldn't show up in the client. Especially with new
exchanges. We should keep all md source/connection configuration in one
place (one proto message), to avoid any confusion.
2024-01-17 01:42:57 -05:00

147 lines
4.4 KiB
C++

#pragma once
#include "UserSymbol.h"
#include "common.h"
#include "lib/api/md/MarketDataConfig.pb.h"
#include "lib/collections/Contains.h"
#include "lib/config/config.h"
#include "lib/config/protos/market_data.pb.h"
#include "lib/config/protos/symbols.pb.h"
#include "lib/core/FMT.h"
#include "lib/domain/DomainSecurityUtils.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):
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