VER: Release 0.18.1

Author: threecgreen

CHANGELOG.md

@@ -1,9 +1,13 @@
 # Changelog
 
-## 0.18.1 - TBD
+## 0.18.1 - 2024-05-22
 
 ### Enhancements
 - Added live `Subscribe` function overload with `use_snapshot` parameter
+- Added `GetIf` method to `Record` that allows `if` chaining for handling multiple
+  record types
+- Added record type checking to `Record::Get` method to catch programming errors
+  and prevent reading invalid data
 
 ### Bug fixes
 - Added missing symbol chunking for live `Subscribe` overloads with `const std::string&`

CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.14)
 # Project details
 #
 
-project("databento" VERSION 0.18.0 LANGUAGES CXX)
+project("databento" VERSION 0.18.1 LANGUAGES CXX)
 string(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UPPERCASE)
 
 #

README.md

@@ -108,10 +108,9 @@ int main() {
 
   auto handler = [&symbol_mappings](const Record& rec) {
     symbol_mappings.OnRecord(rec);
-    if (rec.Holds<TradeMsg>()) {
-      auto trade = rec.Get<TradeMsg>();
+    if (const auto* trade = rec.GetIf<TradeMsg>()) {
       std::cout << "Received trade for "
-                << symbol_mappings[trade.hd.instrument_id] << ':' << trade
+                << symbol_mappings[trade->hd.instrument_id] << ':' << *trade
                 << '\n';
     }
     return KeepGoing::Continue;

example/live/readme.cpp

@@ -18,10 +18,9 @@ int main() {
 
   auto handler = [&symbol_mappings](const Record& rec) {
     symbol_mappings.OnRecord(rec);
-    if (rec.Holds<TradeMsg>()) {
-      auto trade = rec.Get<TradeMsg>();
+    if (const auto* trade = rec.GetIf<TradeMsg>()) {
       std::cout << "Received trade for "
-                << symbol_mappings[trade.hd.instrument_id] << ':' << trade
+                << symbol_mappings[trade->hd.instrument_id] << ':' << *trade
                 << '\n';
     }
     return KeepGoing::Continue;

include/databento/record.hpp

@@ -10,6 +10,7 @@
 #include "databento/constants.hpp"  // kSymbolCstrLen
 #include "databento/datetime.hpp"   // UnixNanos
 #include "databento/enums.hpp"
+#include "databento/exceptions.hpp"  // InvalidArgumentError
 #include "databento/flag_set.hpp"    // FlagSet
 #include "databento/publishers.hpp"  // Publisher
 #include "databento/with_ts_out.hpp"
@@ -54,11 +55,33 @@ class Record {
 
   template <typename T>
   const T& Get() const {
-    return *reinterpret_cast<const T*>(record_);
+    if (const auto* r = GetIf<T>()) {
+      return *r;
+    }
+    throw InvalidArgumentError{
+        "Get", "T", std::string{"rtype mismatch, found "} + ToString(RType())};
   }
   template <typename T>
   T& Get() {
-    return *reinterpret_cast<T*>(record_);
+    if (auto* r = GetIf<T>()) {
+      return *r;
+    }
+    throw InvalidArgumentError{
+        "Get", "T", std::string{"rtype mismatch, found "} + ToString(RType())};
+  }
+  template <typename T>
+  const T* GetIf() const {
+    if (!Holds<T>()) {
+      return nullptr;
+    }
+    return reinterpret_cast<const T*>(record_);
+  }
+  template <typename T>
+  T* GetIf() {
+    if (!Holds<T>()) {
+      return nullptr;
+    }
+    return reinterpret_cast<T*>(record_);
   }
 
   std::size_t Size() const;
@@ -629,6 +652,8 @@ inline bool operator!=(const SymbolMappingMsg& lhs,
 
 std::string ToString(const RecordHeader& header);
 std::ostream& operator<<(std::ostream& stream, const RecordHeader& header);
+std::string ToString(const Record& header);
+std::ostream& operator<<(std::ostream& stream, const Record& header);
 std::string ToString(const MboMsg& mbo_msg);
 std::ostream& operator<<(std::ostream& stream, const MboMsg& mbo_msg);
 std::string ToString(const BidAskPair& ba_pair);

pkg/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Databento <support@databento.com>
 _pkgname=databento-cpp
 pkgname=databento-cpp-git
-pkgver=0.18.0
+pkgver=0.18.1
 pkgrel=1
 pkgdesc="Official C++ client for Databento"
 arch=('any')

src/record.cpp

@@ -189,7 +189,15 @@ bool databento::operator==(const ImbalanceMsg& lhs, const ImbalanceMsg& rhs) {
 }
 
 namespace databento {
-
+std::string ToString(const Record& record) { return MakeString(record); }
+std::ostream& operator<<(std::ostream& stream, const Record& record) {
+  return StreamOpBuilder{stream}
+      .SetSpacer(" ")
+      .SetTypeName("Record")
+      .Build()
+      .AddField("ptr", record.Header())
+      .Finish();
+}
 std::string ToString(const RecordHeader& header) { return MakeString(header); }
 std::ostream& operator<<(std::ostream& stream, const RecordHeader& header) {
   return StreamOpBuilder{stream}

test/src/live_blocking_tests.cpp

@@ -169,19 +169,20 @@ TEST_F(LiveBlockingTests, TestSubscribeSnapshot) {
   const std::size_t kSymbolCount = 1000;
   const auto kSchema = Schema::Ohlcv1M;
   const auto kSType = SType::RawSymbol;
-  const auto use_snapshot = true;
+  const auto kUseSnapshot = true;
 
   const mock::MockLsgServer mock_server{
       kDataset, kTsOut,
-      [kSymbol, kSymbolCount, kSchema, kSType](mock::MockLsgServer& self) {
+      [kSymbol, kSymbolCount, kSchema, kSType,
+       kUseSnapshot](mock::MockLsgServer& self) {
         self.Accept();
         self.Authenticate();
         std::size_t i{};
         while (i < 1000) {
           const auto chunk_size =
               std::min(static_cast<std::size_t>(128), kSymbolCount - i);
           const std::vector<std::string> symbols_chunk(chunk_size, kSymbol);
-          self.Subscribe(symbols_chunk, kSchema, kSType, use_snapshot);
+          self.Subscribe(symbols_chunk, kSchema, kSType, kUseSnapshot);
           i += chunk_size;
         }
       }};
@@ -194,7 +195,7 @@ TEST_F(LiveBlockingTests, TestSubscribeSnapshot) {
                       kTsOut,
                       VersionUpgradePolicy{}};
   const std::vector<std::string> kSymbols(kSymbolCount, kSymbol);
-  target.Subscribe(kSymbols, kSchema, kSType, use_snapshot);
+  target.Subscribe(kSymbols, kSchema, kSType, kUseSnapshot);
 }
 
 TEST_F(LiveBlockingTests, TestInvalidSubscription) {

test/src/live_threaded_tests.cpp

@@ -178,17 +178,17 @@ TEST_F(LiveThreadedTests, TestExceptionCallbackAndReconnect) {
                           {},
                           2};
 
-  const auto use_snapshot = true;
+  const auto kUseSnapshot = true;
   bool should_close{};
   std::mutex should_close_mutex;
   std::condition_variable should_close_cv;
   const mock::MockLsgServer mock_server{
       dataset::kXnasItch, kTsOut,
       [&should_close, &should_close_mutex, &should_close_cv, kRec, kSchema,
-       kSType](mock::MockLsgServer& self) {
+       kSType, kUseSnapshot](mock::MockLsgServer& self) {
         self.Accept();
         self.Authenticate();
-        self.Subscribe(kAllSymbols, kSchema, kSType, use_snapshot);
+        self.Subscribe(kAllSymbols, kSchema, kSType, kUseSnapshot);
         self.Start();
         {
           std::unique_lock<std::mutex> shutdown_lock{should_close_mutex};
@@ -237,7 +237,7 @@ TEST_F(LiveThreadedTests, TestExceptionCallbackAndReconnect) {
     }
   };
 
-  target.Subscribe(kAllSymbols, kSchema, kSType, use_snapshot);
+  target.Subscribe(kAllSymbols, kSchema, kSType, kUseSnapshot);
   target.Start(metadata_cb, record_cb, exception_cb);
   target.BlockForStop();
   EXPECT_EQ(metadata_calls, 2);

test/src/record_tests.cpp

@@ -11,6 +11,28 @@
 
 namespace databento {
 namespace test {
+TEST(RecordTests, TestRecordToString) {
+  TradeMsg target{
+      RecordHeader{sizeof(TradeMsg) / RecordHeader::kLengthMultiplier,
+                   RType::Mbp0,
+                   static_cast<std::uint16_t>(Publisher::OpraPillarEdgo),
+                   1,
+                   {}},
+      55000000000,
+      500,
+      Action::Add,
+      Side::Bid,
+      {},
+      0,
+      {},
+      {},
+      126239};
+  const Record rec{&target.hd};
+  EXPECT_EQ(
+      ToString(rec),
+      "Record { ptr = RecordHeader { length = 12, rtype = Mbp0, publisher_id = "
+      "24, instrument_id = 1, ts_event = 1970-01-01T00:00:00.000000000Z } }");
+}
 TEST(RecordTests, TestPublisher) {
   const TradeMsg target{
       RecordHeader{sizeof(TradeMsg) / RecordHeader::kLengthMultiplier,