Files
spark/src/lib/md/SecurityStore.cpp
T

127 lines
3.6 KiB
C++

#include "SecurityStore.h"
#include "lib/domain/FutureSecurity.h"
#include "lib/domain/Security.h"
#include "lib/utils/LockBox.h"
#include <btree/map.h>
#include <tbb/concurrent_queue.h>
namespace bts::md {
#define SEC_TYPE(x) bts::api::domain::SECURITY_TYPE_##x
#define VENUE(x) bts::api::domain::VENUE_##x
static domain::SecurityID create_sec_id(
api::domain::Venue venue, std::uint32_t exch_id) {
auto val = static_cast<std::uint64_t>(exch_id) |
(static_cast<std::uint32_t>(venue) >> 31);
return domain::SecurityID{val};
}
struct SecurityStore::PImpl {
utils::LockBox<btree::map<domain::SecurityID, SecurityPtr>> cache;
tbb::concurrent_queue<SecurityStore::SecurityPtr> update_queue;
void enqueue_update_db(const SecurityPtr &);
void flush();
static std::uint32_t id_counter;
};
std::uint32_t SecurityStore::PImpl::id_counter = 0;
void SecurityStore::PImpl::enqueue_update_db(const SecurityPtr &security) {
update_queue.push(security);
}
void SecurityStore::PImpl::flush() {
// TODO
}
//////////////////
SecurityStore::SecurityStore()
: me_(std::make_shared<SecurityStore::PImpl>()) {}
SecurityStore::~SecurityStore() {}
const domain::Security *SecurityStore::try_get_security(
domain::SecurityID key) const {
return me_->cache.lock(
[key](btree::map<domain::SecurityID, SecurityPtr> &t)
-> const domain::Security * {
auto iter = t.find(key);
if (iter != t.end()) {
return iter->second.get();
}
return nullptr;
});
}
const domain::Security *SecurityStore::get_security(domain::SecurityID id) {
const auto *result = try_get_security(id);
if (result == nullptr) {
// TODO
}
return result;
}
std::vector<domain::Security const *> SecurityStore::get_securities() {
std::vector<domain::Security const *> result;
result.reserve(100000);
me_->cache.lock([&result](auto &cache) {
for (auto const &p : cache) {
result.push_back(p.second.get());
}
});
return result;
}
const domain::Security *SecurityStore::add_db_security(
const SecurityPtr &security) {
bts_assert(security);
return me_->cache.lock([&security](auto &cache) {
domain::SecurityID id(security->security_common.id);
auto result = cache.insert(std::make_pair(id, security));
// If result was inserted result.first->second is equal to security
// If the value was already present it must be a recently inserted 'live'
// security and we should use it
return result.first->second.get();
});
}
bool SecurityStore::add_security(
api::domain::Venue venue,
api::domain::SecurityType type,
const std::string &symbol) {
if (venue == VENUE(UNSPECIFIED) || symbol.empty() ||
type == SEC_TYPE(UNSPECIFIED)) {
return false;
}
return me_->cache.lock([&](auto &cache) {
// TODO: Complete implementation (this initializes an incomplete security
// atm)
SecurityPtr sptr = std::make_shared<domain::Security>();
domain::Security &s = *sptr;
s.security_common.symbol = symbol;
s.security_common.venue = venue;
s.security_common.id = create_sec_id(venue, me_->id_counter++);
switch (type) {
case SEC_TYPE(FUTURE): {
s.security = domain::FutureSecurity();
break;
}
default:
break;
}
// Insert but don't overwrite existing
auto result = cache.insert(std::make_pair(s.security_common.id, sptr));
me_->enqueue_update_db(sptr);
return result.second;
});
}
void SecurityStore::flush_to_disk() { me_->flush(); }
} // namespace bts::md