ADD: Add new bbo/cbbo schemas to C++ client

Author: renan-databento

CHANGELOG.md

@@ -11,6 +11,9 @@
 - Added logic to skip `find_package` call if `nlohmann_json` and `httplib` targets
   already exist (credit: @akovachev)
 - Added specific instructions for installing dependencies on Ubuntu and macOS (credit: @camrongodbout)
+- Added `CbboMsg` record and corresponding `ConsolidatedBidAskPair` structure
+- Added new enum values for `Schema` and `RType` corresponding to new schemas
+`cbbo`, `cbbo-1s`, `cbbo-1m`, `tcbbo`, `bbo-1s`, `bbo-1m`
 
 ### Bug fixes
 - Fixed out-of-order initialization in `DbnDecoder` (credit: @Hailios)

include/databento/enums.hpp

@@ -34,6 +34,12 @@ enum class Schema : std::uint16_t {
   Statistics = 10,
   Status = 11,
   Imbalance = 12,
+  Cbbo = 14,
+  Cbbo1S = 15,
+  Cbbo1M = 16,
+  Tcbbo = 17,
+  Bbo1S = 18,
+  Bbo1M = 19,
 };
 
 // Represents a data output encoding.
@@ -133,6 +139,12 @@ enum RType : std::uint8_t {
   System = 0x17,
   Statistics = 0x18,
   Mbo = 0xA0,
+  Cbbo = 0xB1,
+  Cbbo1S = 0xC0,
+  Cbbo1M = 0xC1,
+  Tcbbo = 0xC2,
+  Bbo1S = 0xC3,
+  Bbo1M = 0xC4,
 };
 }  // namespace rtype
 using rtype::RType;

include/databento/record.hpp

@@ -102,13 +102,51 @@ struct BidAskPair {
 static_assert(sizeof(BidAskPair) == 32, "BidAskPair size must match Rust");
 static_assert(alignof(BidAskPair) == 8, "Must have 8-byte alignment");
 
-namespace detail {
-template <std::size_t N>
-struct MbpMsg {
-  static_assert(N <= 15, "The maximum number of levels in an MbpMsg is 15");
+struct ConsolidatedBidAskPair {
+  std::int64_t bid_px;
+  std::int64_t ask_px;
+  std::uint32_t bid_sz;
+  std::uint32_t ask_sz;
+  std::uint16_t bid_pb;
+  std::array<char, 2> reserved1;
+  std::uint16_t ask_pb;
+  std::array<char, 2> reserved2;
+};
+static_assert(sizeof(ConsolidatedBidAskPair) == 32,
+              "ConsolidatedBidAskPair size must match Rust");
+static_assert(alignof(ConsolidatedBidAskPair) == 8,
+              "Must have 8-byte alignment");
 
+struct TradeMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::Mbp0; }
+
+  UnixNanos IndexTs() const { return ts_recv; }
+
+  RecordHeader hd;
+  std::int64_t price;
+  std::uint32_t size;
+  Action action;
+  Side side;
+  FlagSet flags;
+  // Depth of the actual book change.
+  std::uint8_t depth;
+  UnixNanos ts_recv;
+  TimeDeltaNanos ts_in_delta;
+  std::uint32_t sequence;
+};
+static_assert(sizeof(TradeMsg) == 48, "TradeMsg size must match Rust");
+static_assert(alignof(TradeMsg) == 8, "Must have 8-byte alignment");
+
+struct Mbp1Msg {
   static bool HasRType(RType rtype) {
-    return static_cast<std::uint8_t>(rtype) == N;
+    switch (rtype) {
+      case RType::Mbp1:   // fallthrough
+      case RType::Bbo1M:  // fallthrough
+      case RType::Bbo1S:
+        return true;
+      default:
+        return false;
+    };
   }
 
   UnixNanos IndexTs() const { return ts_recv; }
@@ -124,12 +162,14 @@ struct MbpMsg {
   UnixNanos ts_recv;
   TimeDeltaNanos ts_in_delta;
   std::uint32_t sequence;
-  std::array<BidAskPair, N> levels;
+  std::array<BidAskPair, 1> levels;
 };
-}  // namespace detail
+using TbboMsg = Mbp1Msg;
+using Bbo1SMsg = Mbp1Msg;
+using Bbo1MMsg = Mbp1Msg;
 
-struct TradeMsg {
-  static bool HasRType(RType rtype) { return rtype == RType::Mbp0; }
+struct Mbp10Msg {
+  static bool HasRType(RType rtype) { return rtype == rtype::Mbp10; }
 
   UnixNanos IndexTs() const { return ts_recv; }
 
@@ -144,13 +184,8 @@ struct TradeMsg {
   UnixNanos ts_recv;
   TimeDeltaNanos ts_in_delta;
   std::uint32_t sequence;
+  std::array<BidAskPair, 10> levels;
 };
-static_assert(sizeof(TradeMsg) == 48, "TradeMsg size must match Rust");
-static_assert(alignof(TradeMsg) == 8, "Must have 8-byte alignment");
-
-using Mbp1Msg = detail::MbpMsg<1>;
-using TbboMsg = Mbp1Msg;
-using Mbp10Msg = detail::MbpMsg<10>;
 
 static_assert(alignof(Mbp1Msg) == 8, "Must have 8-byte alignment");
 static_assert(alignof(Mbp10Msg) == 8, "Must have 8-byte alignment");
@@ -159,6 +194,41 @@ static_assert(sizeof(Mbp1Msg) == sizeof(TradeMsg) + sizeof(BidAskPair),
 static_assert(sizeof(Mbp10Msg) == sizeof(TradeMsg) + sizeof(BidAskPair) * 10,
               "Mbp10Msg size must match Rust");
 
+struct CbboMsg {
+  static bool HasRType(RType rtype) {
+    switch (rtype) {
+      case RType::Cbbo:    // fallthrough
+      case RType::Cbbo1S:  // fallthrough
+      case RType::Cbbo1M:  // fallthrough
+      case RType::Tcbbo:
+        return true;
+      default:
+        return false;
+    };
+  }
+
+  UnixNanos IndexTs() const { return ts_recv; }
+
+  RecordHeader hd;
+  std::int64_t price;
+  std::uint32_t size;
+  Action action;
+  Side side;
+  FlagSet flags;
+  std::array<char, 1> reserved;
+  UnixNanos ts_recv;
+  TimeDeltaNanos ts_in_delta;
+  std::uint32_t sequence;
+  std::array<ConsolidatedBidAskPair, 1> levels;
+};
+using Cbbo1SMsg = CbboMsg;
+using Cbbo1MMsg = CbboMsg;
+using TcbboMsg = CbboMsg;
+static_assert(alignof(CbboMsg) == 8, "Must have 8-byte alignment");
+static_assert(sizeof(CbboMsg) ==
+                  sizeof(TradeMsg) + sizeof(ConsolidatedBidAskPair),
+              "CbboMsg size must match Rust");
+
 // Aggregate of open, high, low, and close prices with volume.
 struct OhlcvMsg {
   static bool HasRType(RType rtype) {
@@ -431,34 +501,49 @@ inline bool operator!=(const BidAskPair& lhs, const BidAskPair& rhs) {
   return !(lhs == rhs);
 }
 
-namespace detail {
-template <std::size_t N>
-bool operator==(const MbpMsg<N>& lhs, const MbpMsg<N>& rhs) {
+inline bool operator==(const ConsolidatedBidAskPair& lhs,
+                       const ConsolidatedBidAskPair& rhs) {
+  return lhs.bid_px == rhs.bid_px && lhs.ask_px == rhs.ask_px &&
+         lhs.bid_sz == rhs.bid_sz && lhs.ask_sz == rhs.ask_sz &&
+         lhs.bid_pb == rhs.bid_pb && lhs.ask_pb == rhs.ask_pb;
+}
+inline bool operator!=(const ConsolidatedBidAskPair& lhs,
+                       const ConsolidatedBidAskPair& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator==(const Mbp1Msg& lhs, const Mbp1Msg& rhs) {
   return lhs.hd == rhs.hd && lhs.price == rhs.price && lhs.size == rhs.size &&
          lhs.action == rhs.action && lhs.side == rhs.side &&
          lhs.flags == rhs.flags && lhs.depth == rhs.depth &&
          lhs.ts_recv == rhs.ts_recv && lhs.ts_in_delta == rhs.ts_in_delta &&
          lhs.sequence == rhs.sequence && lhs.levels == rhs.levels;
 }
-template <std::size_t N>
-bool operator!=(const MbpMsg<N>& lhs, const MbpMsg<N>& rhs) {
+inline bool operator!=(const Mbp1Msg& lhs, const Mbp1Msg& rhs) {
   return !(lhs == rhs);
 }
 
-template <std::size_t N>
-std::string ToString(const MbpMsg<N>& mbp_msg);
-template <>
-std::string ToString(const Mbp1Msg& mbp_msg);
-template <>
-std::string ToString(const Mbp10Msg& mbp_msg);
+inline bool operator==(const Mbp10Msg& lhs, const Mbp10Msg& rhs) {
+  return lhs.hd == rhs.hd && lhs.price == rhs.price && lhs.size == rhs.size &&
+         lhs.action == rhs.action && lhs.side == rhs.side &&
+         lhs.flags == rhs.flags && lhs.depth == rhs.depth &&
+         lhs.ts_recv == rhs.ts_recv && lhs.ts_in_delta == rhs.ts_in_delta &&
+         lhs.sequence == rhs.sequence && lhs.levels == rhs.levels;
+}
+inline bool operator!=(const Mbp10Msg& lhs, const Mbp10Msg& rhs) {
+  return !(lhs == rhs);
+}
 
-template <std::size_t N>
-std::ostream& operator<<(std::ostream& stream, const MbpMsg<N>& mbp_msg);
-template <>
-std::ostream& operator<<(std::ostream& stream, const Mbp1Msg& mbp_msg);
-template <>
-std::ostream& operator<<(std::ostream& stream, const Mbp10Msg& mbp_msg);
-}  // namespace detail
+inline bool operator==(const CbboMsg& lhs, const CbboMsg& rhs) {
+  return lhs.hd == rhs.hd && lhs.price == rhs.price && lhs.size == rhs.size &&
+         lhs.action == rhs.action && lhs.side == rhs.side &&
+         lhs.flags == rhs.flags && lhs.ts_recv == rhs.ts_recv &&
+         lhs.ts_in_delta == rhs.ts_in_delta && lhs.sequence == rhs.sequence &&
+         lhs.levels == rhs.levels;
+}
+inline bool operator!=(const CbboMsg& lhs, const CbboMsg& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const TradeMsg& lhs, const TradeMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.price == rhs.price && lhs.size == rhs.size &&
@@ -549,6 +634,15 @@ std::string ToString(const MboMsg& mbo_msg);
 std::ostream& operator<<(std::ostream& stream, const MboMsg& mbo_msg);
 std::string ToString(const BidAskPair& ba_pair);
 std::ostream& operator<<(std::ostream& stream, const BidAskPair& ba_pair);
+std::string ToString(const ConsolidatedBidAskPair& ba_pair);
+std::ostream& operator<<(std::ostream& stream,
+                         const ConsolidatedBidAskPair& ba_pair);
+std::string ToString(const Mbp1Msg& mbp_msg);
+std::ostream& operator<<(std::ostream& stream, const Mbp1Msg& mbp_msg);
+std::string ToString(const Mbp10Msg& mbp_msg);
+std::ostream& operator<<(std::ostream& stream, const Mbp10Msg& mbp_msg);
+std::string ToString(const CbboMsg& mbp_msg);
+std::ostream& operator<<(std::ostream& stream, const CbboMsg& mbp_msg);
 std::string ToString(const TradeMsg& trade_msg);
 std::ostream& operator<<(std::ostream& stream, const TradeMsg& trade_msg);
 std::string ToString(const OhlcvMsg& ohlcv_msg);

src/enums.cpp

@@ -62,6 +62,24 @@ const char* ToString(Schema schema) {
     case Schema::Status: {
       return "status";
     }
+    case Schema::Cbbo: {
+      return "cbbo";
+    }
+    case Schema::Cbbo1S: {
+      return "cbbo-1s";
+    }
+    case Schema::Cbbo1M: {
+      return "cbbo-1m";
+    }
+    case Schema::Tcbbo: {
+      return "tcbbo";
+    }
+    case Schema::Bbo1S: {
+      return "bbo-1s";
+    }
+    case Schema::Bbo1M: {
+      return "bbo-1m";
+    }
     default: {
       return "unknown";
     }
@@ -286,6 +304,24 @@ const char* ToString(RType rtype) {
     case RType::Mbo: {
       return "Mbo";
     }
+    case RType::Cbbo: {
+      return "Cbbo";
+    }
+    case RType::Cbbo1S: {
+      return "Cbbo1S";
+    }
+    case RType::Cbbo1M: {
+      return "Cbbo1M";
+    }
+    case RType::Tcbbo: {
+      return "Tcbbo";
+    }
+    case RType::Bbo1S: {
+      return "Bbo1S";
+    }
+    case RType::Bbo1M: {
+      return "Bbo1M";
+    }
     default: {
       return "Unknown";
     }