ADD: Add instrument definitions to C++ client lib

Author: threecgreen

include/databento/record.hpp

@@ -127,6 +127,7 @@ static_assert(sizeof(TradeMsg) == 48, "TradeMsg size must match C");
 static_assert(sizeof(Mbp1Msg) == sizeof(TradeMsg) + sizeof(BidAskPair),
               "Mbp1Msg size must match C");
 
+// Aggregate of open, high, low, and close prices with volume.
 struct OhlcvMsg {
   static constexpr std::uint8_t kTypeId = 0x11;
 
@@ -140,11 +141,86 @@ struct OhlcvMsg {
 
 static_assert(sizeof(OhlcvMsg) == 56, "OhlcvMsg size must match C");
 
+// Instrument definition.
+struct InstrumentDefMsg {
+  static constexpr std::uint8_t kTypeId = 0x13;
+
+  RecordHeader hd;
+  UnixNanos ts_recv;
+  std::int64_t min_price_increment;
+  std::int64_t display_factor;
+  std::uint64_t expiration;
+  std::uint64_t activation;
+  std::int64_t high_limit_price;
+  std::int64_t low_limit_price;
+  std::int64_t max_price_variation;
+  std::int64_t trading_reference_price;
+  std::int64_t unit_of_measure_qty;
+  std::int64_t min_price_increment_amount;
+  std::int64_t price_ratio;
+  std::int32_t inst_attrib_value;
+  std::uint32_t underlying_id;
+  std::int32_t cleared_volume;
+  std::int32_t market_depth_implied;
+  std::int32_t market_depth;
+  std::uint32_t market_segment_id;
+  std::uint32_t max_trade_vol;
+  std::int32_t min_lot_size;
+  std::int32_t min_lot_size_block;
+  std::int32_t min_lot_size_round_lot;
+  std::uint32_t min_trade_vol;
+  std::int32_t open_interest_qty;
+  std::int32_t contract_multiplier;
+  std::int32_t decay_quantity;
+  std::int32_t original_contract_size;
+  std::uint32_t related_security_id;
+  std::uint16_t trading_reference_date;
+  std::int16_t appl_id;
+  std::uint16_t maturity_year;
+  std::uint16_t decay_start_date;
+  std::uint16_t channel_id;
+  std::array<char, 4> currency;
+  std::array<char, 4> settl_currency;
+  std::array<char, 6> secsubtype;
+  std::array<char, 22> symbol;
+  std::array<char, 21> group;
+  std::array<char, 5> exchange;
+  std::array<char, 7> asset;
+  std::array<char, 7> cfi;
+  std::array<char, 7> security_type;
+  std::array<char, 31> unit_of_measure;
+  std::array<char, 21> underlying;
+  std::array<char, 21> related;
+  char match_algorithm;
+  std::uint8_t md_security_trading_status;
+  std::uint8_t main_fraction;
+  std::uint8_t price_display_format;
+  std::uint8_t settl_price_type;
+  std::uint8_t sub_fraction;
+  std::uint8_t underlying_product;
+  char security_update_action;
+  std::uint8_t maturity_month;
+  std::uint8_t maturity_day;
+  std::uint8_t maturity_week;
+  char user_defined_instrument;
+  std::int8_t contract_multiplier_unit;
+  std::int8_t flow_schedule_type;
+  std::uint8_t tick_rule;
+  // padding for alignment
+  std::array<char, 3> dummy;
+};
+
+static_assert(sizeof(InstrumentDefMsg) == 360,
+              "InstrumentDefMsg size must match C");
+
 inline bool operator==(const RecordHeader& lhs, const RecordHeader& rhs) {
   return lhs.length == rhs.length && lhs.rtype == rhs.rtype &&
          lhs.publisher_id == rhs.publisher_id &&
          lhs.product_id == rhs.product_id && lhs.ts_event == rhs.ts_event;
 }
+inline bool operator!=(const RecordHeader& lhs, const RecordHeader& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const MboMsg& lhs, const MboMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.order_id == rhs.order_id &&
@@ -154,12 +230,18 @@ inline bool operator==(const MboMsg& lhs, const MboMsg& rhs) {
          lhs.ts_recv == rhs.ts_recv && lhs.ts_in_delta == rhs.ts_in_delta &&
          lhs.sequence == rhs.sequence;
 }
+inline bool operator!=(const TickMsg& lhs, const TickMsg& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const BidAskPair& lhs, const BidAskPair& 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_ct == rhs.bid_ct && lhs.ask_ct == rhs.ask_ct;
 }
+inline bool operator!=(const BidAskPair& lhs, const BidAskPair& rhs) {
+  return !(lhs == rhs);
+}
 
 namespace detail {
 template <std::size_t N>
@@ -170,6 +252,10 @@ bool operator==(const MbpMsg<N>& lhs, const MbpMsg<N>& rhs) {
          lhs.ts_recv == rhs.ts_recv && lhs.ts_in_delta == rhs.ts_in_delta &&
          lhs.sequence == rhs.sequence && lhs.booklevel == rhs.booklevel;
 }
+template <std::size_t N>
+bool operator!=(const MbpMsg<N>& lhs, const MbpMsg<N>& rhs) {
+  return !(lhs == rhs);
+}
 
 template <std::size_t N>
 std::string ToString(const MbpMsg<N>& mbp_msg);
@@ -193,12 +279,24 @@ inline bool operator==(const TradeMsg& lhs, const TradeMsg& rhs) {
          lhs.ts_recv == rhs.ts_recv && lhs.ts_in_delta == rhs.ts_in_delta &&
          lhs.sequence == rhs.sequence;
 }
+inline bool operator!=(const TradeMsg& lhs, const TradeMsg& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const OhlcvMsg& lhs, const OhlcvMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.open == rhs.open && lhs.high == rhs.high &&
          lhs.low == rhs.low && lhs.close == rhs.close &&
          lhs.volume == rhs.volume;
 }
+inline bool operator!=(const OhlcvMsg& lhs, const OhlcvMsg& rhs) {
+  return !(lhs == rhs);
+}
+
+bool operator==(const InstrumentDefMsg& lhs, const InstrumentDefMsg& rhs);
+inline bool operator!=(const InstrumentDefMsg& lhs,
+                       const InstrumentDefMsg& rhs) {
+  return !(lhs == rhs);
+}
 
 std::string ToString(const RecordHeader& header);
 std::ostream& operator<<(std::ostream& stream, const RecordHeader& header);
@@ -210,4 +308,7 @@ std::string ToString(const TradeMsg& trade_msg);
 std::ostream& operator<<(std::ostream& stream, const TradeMsg& trade_msg);
 std::string ToString(const OhlcvMsg& ohlcv_msg);
 std::ostream& operator<<(std::ostream& stream, const OhlcvMsg& ohlcv_msg);
+std::string ToString(const InstrumentDefMsg& instr_def_msg);
+std::ostream& operator<<(std::ostream& stream,
+                         const InstrumentDefMsg& instr_def_msg);
 }  // namespace databento

src/record.cpp

@@ -27,6 +27,9 @@ std::size_t Record::SizeOfType(const std::uint8_t rtype) {
     case OhlcvMsg::kTypeId: {
       return sizeof(OhlcvMsg);
     }
+    case InstrumentDefMsg::kTypeId: {
+      return sizeof(InstrumentDefMsg);
+    }
     default: {
       throw InvalidArgumentError{
           "Record::SizeOfType", "rtype",
@@ -58,6 +61,9 @@ std::uint8_t Record::TypeIdFromSchema(const Schema schema) {
     case Schema::Ohlcv1S: {
       return OhlcvMsg::kTypeId;
     }
+    case Schema::Definition: {
+      return InstrumentDefMsg::kTypeId;
+    }
     default: {
       throw InvalidArgumentError{
           "Record::TypeIdFromSchema", "schema",
@@ -67,6 +73,65 @@ std::uint8_t Record::TypeIdFromSchema(const Schema schema) {
   }
 }
 
+using databento::InstrumentDefMsg;
+
+bool databento::operator==(const InstrumentDefMsg& lhs,
+                           const InstrumentDefMsg& rhs) {
+  return lhs.hd == rhs.hd && lhs.ts_recv == rhs.ts_recv &&
+         lhs.min_price_increment == rhs.min_price_increment &&
+         lhs.display_factor == rhs.display_factor &&
+         lhs.expiration == rhs.expiration && lhs.activation == rhs.activation &&
+         lhs.high_limit_price == rhs.high_limit_price &&
+         lhs.low_limit_price == rhs.low_limit_price &&
+         lhs.max_price_variation == rhs.max_price_variation &&
+         lhs.trading_reference_price == rhs.trading_reference_price &&
+         lhs.unit_of_measure_qty == rhs.unit_of_measure_qty &&
+         lhs.min_price_increment_amount == rhs.min_price_increment_amount &&
+         lhs.price_ratio == rhs.price_ratio &&
+         lhs.inst_attrib_value == rhs.inst_attrib_value &&
+         lhs.underlying_id == rhs.underlying_id &&
+         lhs.cleared_volume == rhs.cleared_volume &&
+         lhs.market_depth_implied == rhs.market_depth_implied &&
+         lhs.market_depth == rhs.market_depth &&
+         lhs.market_segment_id == rhs.market_segment_id &&
+         lhs.max_trade_vol == rhs.max_trade_vol &&
+         lhs.min_lot_size == rhs.min_lot_size &&
+         lhs.min_lot_size_block == rhs.min_lot_size_block &&
+         lhs.min_lot_size_round_lot == rhs.min_lot_size_round_lot &&
+         lhs.min_trade_vol == rhs.min_trade_vol &&
+         lhs.open_interest_qty == rhs.open_interest_qty &&
+         lhs.contract_multiplier == rhs.contract_multiplier &&
+         lhs.decay_quantity == rhs.decay_quantity &&
+         lhs.original_contract_size == rhs.original_contract_size &&
+         lhs.related_security_id == rhs.related_security_id &&
+         lhs.trading_reference_date == rhs.trading_reference_date &&
+         lhs.appl_id == rhs.appl_id && lhs.maturity_year == rhs.maturity_year &&
+         lhs.decay_start_date == rhs.decay_start_date &&
+         lhs.channel_id == rhs.channel_id && lhs.currency == rhs.currency &&
+         lhs.settl_currency == rhs.settl_currency &&
+         lhs.secsubtype == rhs.secsubtype && lhs.symbol == rhs.symbol &&
+         lhs.group == rhs.group && lhs.exchange == rhs.exchange &&
+         lhs.asset == rhs.asset && lhs.cfi == rhs.cfi &&
+         lhs.security_type == rhs.security_type &&
+         lhs.unit_of_measure == rhs.unit_of_measure &&
+         lhs.underlying == rhs.underlying && lhs.related == rhs.related &&
+         lhs.match_algorithm == rhs.match_algorithm &&
+         lhs.md_security_trading_status == rhs.md_security_trading_status &&
+         lhs.main_fraction == rhs.main_fraction &&
+         lhs.price_display_format == rhs.price_display_format &&
+         lhs.settl_price_type == rhs.settl_price_type &&
+         lhs.sub_fraction == rhs.sub_fraction &&
+         lhs.underlying_product == rhs.underlying_product &&
+         lhs.security_update_action == rhs.security_update_action &&
+         lhs.maturity_month == rhs.maturity_month &&
+         lhs.maturity_day == rhs.maturity_day &&
+         lhs.maturity_week == rhs.maturity_week &&
+         lhs.user_defined_instrument == rhs.user_defined_instrument &&
+         lhs.contract_multiplier_unit == rhs.contract_multiplier_unit &&
+         lhs.flow_schedule_type == rhs.flow_schedule_type &&
+         lhs.tick_rule == rhs.tick_rule;
+}
+
 namespace databento {
 namespace detail {
 template <>
@@ -206,4 +271,81 @@ std::ostream& operator<<(std::ostream& stream, const OhlcvMsg& ohlcv_msg) {
       .AddField("volume", ohlcv_msg.volume)
       .Finish();
 }
+std::string ToString(const InstrumentDefMsg& instr_def_msg) {
+  return MakeString(instr_def_msg);
+}
+std::ostream& operator<<(std::ostream& stream,
+                         const InstrumentDefMsg& instr_def_msg) {
+  return StreamOpBuilder{stream}
+      .SetSpacer("\n    ")
+      .SetTypeName("InstrumentDefMsg")
+      .Build()
+      .AddField("hd", instr_def_msg.hd)
+      .AddField("ts_recv", instr_def_msg.ts_recv)
+      .AddField("min_price_increment", instr_def_msg.min_price_increment)
+      .AddField("display_factor", instr_def_msg.display_factor)
+      .AddField("expiration", instr_def_msg.expiration)
+      .AddField("activation", instr_def_msg.activation)
+      .AddField("high_limit_price", instr_def_msg.high_limit_price)
+      .AddField("low_limit_price", instr_def_msg.low_limit_price)
+      .AddField("max_price_variation", instr_def_msg.max_price_variation)
+      .AddField("trading_reference_price",
+                instr_def_msg.trading_reference_price)
+      .AddField("unit_of_measure_qty", instr_def_msg.unit_of_measure_qty)
+      .AddField("min_price_increment_amount",
+                instr_def_msg.min_price_increment_amount)
+      .AddField("price_ratio", instr_def_msg.price_ratio)
+      .AddField("inst_attrib_value", instr_def_msg.inst_attrib_value)
+      .AddField("underlying_id", instr_def_msg.underlying_id)
+      .AddField("cleared_volume", instr_def_msg.cleared_volume)
+      .AddField("market_depth_implied", instr_def_msg.market_depth_implied)
+      .AddField("market_depth", instr_def_msg.market_depth)
+      .AddField("market_segment_id", instr_def_msg.market_segment_id)
+      .AddField("max_trade_vol", instr_def_msg.max_trade_vol)
+      .AddField("min_lot_size", instr_def_msg.min_lot_size)
+      .AddField("min_lot_size_block", instr_def_msg.min_lot_size_block)
+      .AddField("min_lot_size_round_lot", instr_def_msg.min_lot_size_round_lot)
+      .AddField("min_trade_vol", instr_def_msg.min_trade_vol)
+      .AddField("open_interest_qty", instr_def_msg.open_interest_qty)
+      .AddField("contract_multiplier", instr_def_msg.contract_multiplier)
+      .AddField("decay_quantity", instr_def_msg.decay_quantity)
+      .AddField("original_contract_size", instr_def_msg.original_contract_size)
+      .AddField("related_security_id", instr_def_msg.related_security_id)
+      .AddField("trading_reference_date", instr_def_msg.trading_reference_date)
+      .AddField("appl_id", instr_def_msg.appl_id)
+      .AddField("maturity_year", instr_def_msg.maturity_year)
+      .AddField("decay_start_date", instr_def_msg.decay_start_date)
+      .AddField("channel_id", instr_def_msg.channel_id)
+      .AddField("currency", instr_def_msg.currency)
+      .AddField("settl_currency", instr_def_msg.settl_currency)
+      .AddField("secsubtype", instr_def_msg.secsubtype)
+      .AddField("symbol", instr_def_msg.symbol)
+      .AddField("group", instr_def_msg.group)
+      .AddField("exchange", instr_def_msg.exchange)
+      .AddField("asset", instr_def_msg.asset)
+      .AddField("cfi", instr_def_msg.cfi)
+      .AddField("security_type", instr_def_msg.security_type)
+      .AddField("unit_of_measure", instr_def_msg.unit_of_measure)
+      .AddField("underlying", instr_def_msg.underlying)
+      .AddField("related", instr_def_msg.related)
+      .AddField("match_algorithm", instr_def_msg.match_algorithm)
+      .AddField("md_security_trading_status",
+                instr_def_msg.md_security_trading_status)
+      .AddField("main_fraction", instr_def_msg.main_fraction)
+      .AddField("price_display_format", instr_def_msg.price_display_format)
+      .AddField("settl_price_type", instr_def_msg.settl_price_type)
+      .AddField("sub_fraction", instr_def_msg.sub_fraction)
+      .AddField("underlying_product", instr_def_msg.underlying_product)
+      .AddField("security_update_action", instr_def_msg.security_update_action)
+      .AddField("maturity_month", instr_def_msg.maturity_month)
+      .AddField("maturity_day", instr_def_msg.maturity_day)
+      .AddField("maturity_week", instr_def_msg.maturity_week)
+      .AddField("user_defined_instrument",
+                instr_def_msg.user_defined_instrument)
+      .AddField("contract_multiplier_unit",
+                instr_def_msg.contract_multiplier_unit)
+      .AddField("flow_schedule_type", instr_def_msg.flow_schedule_type)
+      .AddField("tick_rule", instr_def_msg.tick_rule)
+      .Finish();
+}
 }  // namespace databento

src/stream_op_helper.hpp

@@ -1,13 +1,15 @@
 #pragma once
 
+#include <array>
 #include <cstdint>
-#include <ios>
-#include <ostream>
-#include <sstream>
+#include <cstring>  // strlen
+#include <ios>      // boolalpha
+#include <ostream>  // ostream
+#include <sstream>  // stringstream
 #include <string>
-#include <utility>
+#include <utility>  // move
 
-#include "databento/datetime.hpp"
+#include "databento/datetime.hpp"  // TimeDeltaNanos, UnixNanos
 
 namespace databento {
 template <typename T>
@@ -53,6 +55,14 @@ class StreamOpHelper {
 
   void FmtToStream(const std::ostringstream& val) { stream_ << val.str(); }
 
+  template <std::size_t N>
+  void FmtToStream(const std::array<char, N>& val) {
+    stream_ << '"';
+    stream_.write(val.data(),
+                  static_cast<std::streamsize>(::strlen(val.data())));
+    stream_ << '"';
+  }
+
  public:
   StreamOpHelper(std::ostream& stream, const std::string& type_name,
                  std::string spacer, std::string indent)