#include "SecurityStore.h" #include "lib/domain/FutureSecurity.h" #include "lib/domain/Security.h" #include "lib/utils/LockBox.h" #include #include 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(exch_id) | (static_cast(venue) >> 31); return domain::SecurityID{val}; } struct SecurityStore::PImpl { utils::LockBox> cache; tbb::concurrent_queue 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::~SecurityStore() {} const domain::Security *SecurityStore::try_get_security( domain::SecurityID key) const { return me_->cache.lock( [key](btree::map &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 SecurityStore::get_securities() { std::vector 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 &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