127 lines
3.6 KiB
C++
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
|