MOD: Rename method to …GetDatasetCondition

Author: threecgreen

example/metadata.cpp

@@ -50,9 +50,9 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto conditions = client.MetadataListDatasetConditions(
+  const auto dataset_condition = client.MetadataGetDatasetCondition(
       "GLBX.MDP3", "2019-06-01", "2019-08-01");
-  std::cout << conditions << "\n\n";
+  std::cout << dataset_condition << "\n\n";
 
   const auto compressions = client.MetadataListCompressions();
   std::cout << "Compressions:\n";

include/databento/historical.hpp

@@ -11,7 +11,7 @@
 #include "databento/detail/http_client.hpp"  // HttpClient
 #include "databento/enums.hpp"  // BatchState, Delivery, DurationInterval, Packaging, Schema, SType
 #include "databento/file_bento.hpp"
-#include "databento/metadata.hpp"  // FieldsByDatasetEncodingAndSchema, DatasetConditions, PriceByFeedMode, PriceByFeedModeAndSchema, PriceBySchema
+#include "databento/metadata.hpp"  // DatasetConditionInfo, FieldsByDatasetEncodingAndSchema, PriceByFeedMode, PriceByFeedModeAndSchema, PriceBySchema
 #include "databento/symbology.hpp"  // SymbologyResolution
 #include "databento/timeseries.hpp"  // KeepGoing, MetadataCallback, RecordCallback
 
@@ -82,16 +82,16 @@ class Historical {
       const std::string& dataset, Encoding encoding, Schema schema);
   std::vector<Encoding> MetadataListEncodings();
   std::vector<Compression> MetadataListCompressions();
-  DatasetConditions MetadataListDatasetConditions(const std::string& dataset,
-                                                  const std::string& start_date,
-                                                  const std::string& end_date);
   PriceByFeedModeAndSchema MetadataListUnitPrices(const std::string& dataset);
   PriceBySchema MetadataListUnitPrices(const std::string& dataset,
                                        FeedMode mode);
   PriceByFeedMode MetadataListUnitPrices(const std::string& dataset,
                                          Schema schema);
   double MetadataListUnitPrices(const std::string& dataset, FeedMode mode,
                                 Schema schema);
+  DatasetConditionInfo MetadataGetDatasetCondition(
+      const std::string& dataset, const std::string& start_date,
+      const std::string& end_date);
   std::size_t MetadataGetRecordCount(const std::string& dataset,
                                      UnixNanos start, UnixNanos end,
                                      const std::vector<std::string>& symbols,

include/databento/metadata.hpp

@@ -23,7 +23,7 @@ struct DatasetConditionDetail {
   DatasetCondition condition;
 };
 
-struct DatasetConditions {
+struct DatasetConditionInfo {
   // Overall condition for the date range.
   DatasetCondition condition;
   // The dataset condition by date.
@@ -35,7 +35,7 @@ struct DatasetConditions {
 std::string ToString(const DatasetConditionDetail& condition_detail);
 std::ostream& operator<<(std::ostream& stream,
                          const DatasetConditionDetail& condition_detail);
-std::string ToString(const DatasetConditions& conditions);
+std::string ToString(const DatasetConditionInfo& condition);
 std::ostream& operator<<(std::ostream& stream,
-                         const DatasetConditions& conditions);
+                         const DatasetConditionInfo& condition);
 }  // namespace databento

src/detail/http_client.cpp

@@ -50,7 +50,7 @@ void HttpClient::GetRawStream(const std::string& path,
   const std::string full_path = httplib::append_query_params(path, params);
   std::string err_body{};
   int err_status{};
-  httplib::Result res = client_.Get(
+  const httplib::Result res = client_.Get(
       full_path,
       [&err_status](const httplib::Response& resp) {
         if (HttpClient::IsErrorStatus(resp.status)) {

src/detail/shared_channel.cpp

@@ -65,14 +65,14 @@ SharedChannel::Channel::~Channel() { Finish(); }
 
 void SharedChannel::Channel::Write(const std::uint8_t* data,
                                    std::size_t length) {
-  std::lock_guard<std::mutex> lock{mutex_};
+  const std::lock_guard<std::mutex> lock{mutex_};
   stream_.write(reinterpret_cast<const char*>(data),
                 static_cast<std::streamsize>(length));
   cv_.notify_one();
 }
 
 void SharedChannel::Channel::Finish() {
-  std::lock_guard<std::mutex> lock{mutex_};
+  const std::lock_guard<std::mutex> lock{mutex_};
   is_finished_ = true;
   cv_.notify_one();
 }

src/detail/socket.cpp

@@ -23,7 +23,10 @@ Socket::Socket(const std::string& addr, std::uint16_t port)
     throw InvalidArgumentError{"Socket::Socket", "addr",
                                "Unable to convert to a binary IPv4 address"};
   }
-  const sockaddr_in addr_in{AF_INET, ::htons(port), network_addr, {}};
+  sockaddr_in addr_in{};
+  addr_in.sin_family = AF_INET;
+  addr_in.sin_port = htons(port);
+  addr_in.sin_addr = network_addr;
   if (::connect(fd_, reinterpret_cast<const sockaddr*>(&addr_in),
                 sizeof(sockaddr_in)) != 0) {
     ::close(fd_);

src/historical.cpp

@@ -524,39 +524,6 @@ std::vector<databento::Compression> Historical::MetadataListCompressions() {
   return compressions;
 }
 
-databento::DatasetConditions Historical::MetadataListDatasetConditions(
-    const std::string& dataset, const std::string& start_date,
-    const std::string& end_date) {
-  static const std::string kEndpoint =
-      "Historical::MetadataListDatasetConditions";
-  static const std::string kPath =
-      ::BuildMetadataPath(".list_dataset_conditions");
-
-  const nlohmann::json json =
-      client_.GetJson(kPath, httplib::Params{{"dataset", dataset},
-                                             {"start_date", start_date},
-                                             {"end_date", end_date}});
-  if (!json.is_object()) {
-    throw JsonResponseError::TypeMismatch(kEndpoint, "object", json);
-  }
-  const auto& details_json = CheckedAt(kEndpoint, json, "details");
-  if (!details_json.is_array()) {
-    throw JsonResponseError::TypeMismatch(kEndpoint, "details array", json);
-  }
-  std::vector<DatasetConditionDetail> details;
-  details.reserve(details_json.size());
-  for (const auto& detail_json : details_json.items()) {
-    details.emplace_back(DatasetConditionDetail{
-        ParseAt<std::string>(kEndpoint, detail_json.value(), "date"),
-        FromCheckedAtString<DatasetCondition>(kEndpoint, detail_json.value(),
-                                              "condition")});
-  }
-  return {FromCheckedAtString<DatasetCondition>(kEndpoint, json, "condition"),
-          std::move(details),
-          ParseAt<std::string>(kEndpoint, json, "adjusted_start_date"),
-          ParseAt<std::string>(kEndpoint, json, "adjusted_end_date")};
-}
-
 static const std::string kListUnitPricesEndpoint =
     "Historical::MetadataListUnitPrices";
 static const std::string kListUnitPricesPath =
@@ -657,6 +624,39 @@ double Historical::MetadataListUnitPrices(const std::string& dataset,
   return json;
 }
 
+databento::DatasetConditionInfo Historical::MetadataGetDatasetCondition(
+    const std::string& dataset, const std::string& start_date,
+    const std::string& end_date) {
+  static const std::string kEndpoint =
+      "Historical::MetadataGetDatasetCondition";
+  static const std::string kPath =
+      ::BuildMetadataPath(".get_dataset_condition");
+
+  const nlohmann::json json =
+      client_.GetJson(kPath, httplib::Params{{"dataset", dataset},
+                                             {"start_date", start_date},
+                                             {"end_date", end_date}});
+  if (!json.is_object()) {
+    throw JsonResponseError::TypeMismatch(kEndpoint, "object", json);
+  }
+  const auto& details_json = CheckedAt(kEndpoint, json, "details");
+  if (!details_json.is_array()) {
+    throw JsonResponseError::TypeMismatch(kEndpoint, "details array", json);
+  }
+  std::vector<DatasetConditionDetail> details;
+  details.reserve(details_json.size());
+  for (const auto& detail_json : details_json.items()) {
+    details.emplace_back(DatasetConditionDetail{
+        ParseAt<std::string>(kEndpoint, detail_json.value(), "date"),
+        FromCheckedAtString<DatasetCondition>(kEndpoint, detail_json.value(),
+                                              "condition")});
+  }
+  return {FromCheckedAtString<DatasetCondition>(kEndpoint, json, "condition"),
+          std::move(details),
+          ParseAt<std::string>(kEndpoint, json, "adjusted_start_date"),
+          ParseAt<std::string>(kEndpoint, json, "adjusted_end_date")};
+}
+
 std::size_t Historical::MetadataGetRecordCount(
     const std::string& dataset, UnixNanos start, UnixNanos end,
     const std::vector<std::string>& symbols, Schema schema) {
@@ -959,8 +959,8 @@ void Historical::TimeseriesStream(const HttplibParams& params,
   std::exception_ptr exception_ptr{};
   std::mutex exception_ptr_mutex;
   // no initialized lambda captures until C++14
-  ScopedThread stream{[this, &channel, &exception_ptr, &exception_ptr_mutex,
-                       &params, &should_continue] {
+  const ScopedThread stream{[this, &channel, &exception_ptr,
+                             &exception_ptr_mutex, &params, &should_continue] {
     try {
       this->client_.GetRawStream(
           kTimeseriesStreamPath, params,
@@ -972,7 +972,7 @@ void Historical::TimeseriesStream(const HttplibParams& params,
       channel.Finish();
     } catch (const std::exception&) {
       channel.Finish();
-      std::lock_guard<std::mutex> guard{exception_ptr_mutex};
+      const std::lock_guard<std::mutex> guard{exception_ptr_mutex};
       // rethrowing here will cause the process to be terminated
       exception_ptr = std::current_exception();
     }
@@ -990,7 +990,7 @@ void Historical::TimeseriesStream(const HttplibParams& params,
   } catch (const std::exception& exc) {
     should_continue = false;
     // check if there's an exception from stream thread
-    std::lock_guard<std::mutex> guard{exception_ptr_mutex};
+    const std::lock_guard<std::mutex> guard{exception_ptr_mutex};
     if (exception_ptr) {
       std::rethrow_exception(exception_ptr);
     }

src/metadata.cpp

@@ -19,28 +19,28 @@ std::ostream& operator<<(std::ostream& stream,
       .Finish();
 }
 
-std::string ToString(const DatasetConditions& conditions) {
-  return MakeString(conditions);
+std::string ToString(const DatasetConditionInfo& condition) {
+  return MakeString(condition);
 }
 std::ostream& operator<<(std::ostream& stream,
-                         const DatasetConditions& conditions) {
+                         const DatasetConditionInfo& condition) {
   std::ostringstream details_stream;
   auto details_helper = StreamOpBuilder{details_stream}
                             .SetSpacer("\n    ")
                             .SetIndent("    ")
                             .Build();
-  for (const auto& detail : conditions.details) {
+  for (const auto& detail : condition.details) {
     details_helper.AddItem(detail);
   }
   return StreamOpBuilder{stream}
       .SetSpacer("\n    ")
-      .SetTypeName("DatasetConditions")
+      .SetTypeName("DatasetConditionInfo")
       .Build()
-      .AddField("condition", conditions.condition)
+      .AddField("condition", condition.condition)
       .AddField("details",
                 static_cast<std::ostringstream&>(details_helper.Finish()))
-      .AddField("adjusted_start_date", conditions.adjusted_start_date)
-      .AddField("adjusted_end_date", conditions.adjusted_end_date)
+      .AddField("adjusted_start_date", condition.adjusted_start_date)
+      .AddField("adjusted_end_date", condition.adjusted_end_date)
       .Finish();
 }
 }  // namespace databento

test/src/historical_tests.cpp

@@ -315,7 +315,7 @@ TEST_F(HistoricalTests, TestMetadataListCompressions) {
   EXPECT_EQ(res, kExp);
 }
 
-TEST_F(HistoricalTests, TestMetadataListDatasetConditions) {
+TEST_F(HistoricalTests, TestMetadataGetDatasetCondition) {
   const nlohmann::json kResp{
       {"condition", "bad"},
       {"details",
@@ -325,7 +325,7 @@ TEST_F(HistoricalTests, TestMetadataListDatasetConditions) {
         {{"date", "2022-11-10"}, {"condition", "available"}}}},
       {"adjusted_start_date", "2022-11-07"},
       {"adjusted_end_date", "2022-11-10"}};
-  mock_server_.MockGetJson("/v0/metadata.list_dataset_conditions",
+  mock_server_.MockGetJson("/v0/metadata.get_dataset_condition",
                            {{"dataset", dataset::kXnasItch},
                             {"start_date", "2022-11-06"},
                             {"end_date", "2022-11-10"}},
@@ -334,7 +334,7 @@ TEST_F(HistoricalTests, TestMetadataListDatasetConditions) {
 
   databento::Historical target{kApiKey, "localhost",
                                static_cast<std::uint16_t>(port)};
-  const auto res = target.MetadataListDatasetConditions(
+  const auto res = target.MetadataGetDatasetCondition(
       dataset::kXnasItch, "2022-11-06", "2022-11-10");
   EXPECT_EQ(res.condition, DatasetCondition::Bad);
   ASSERT_EQ(res.details.size(), 4);
@@ -683,7 +683,7 @@ TEST_F(HistoricalTests, TestTimeseriesStreamToFile) {
 
   databento::Historical target{kApiKey, "localhost",
                                static_cast<std::uint16_t>(port)};
-  TempFile temp_file{testing::TempDir() + "/" + __FUNCTION__};
+  const TempFile temp_file{testing::TempDir() + "/" + __FUNCTION__};
   target.TimeseriesStreamToFile(dataset::kGlbxMdp3, "2022-10-21T13:30",
                                 "2022-10-21T20:00", {"CYZ2"}, Schema::Tbbo,
                                 temp_file.Path());

test/src/metadata_tests.cpp

@@ -13,16 +13,17 @@ TEST(MetadataTests, TestDatasetConditionDetailToString) {
       R"(DatasetConditionDetail { date = "2022-11-10", condition = available })");
 }
 
-TEST(MetadataTests, TestDatasetConditionsToString) {
-  const DatasetConditions target{DatasetCondition::Bad,
-                                 {{"2022-11-07", DatasetCondition::Available},
-                                  {"2022-11-08", DatasetCondition::Bad},
-                                  {"2022-11-09", DatasetCondition::Bad},
-                                  {"2022-11-10", DatasetCondition::Available}},
-                                 "2022-11-07",
-                                 "2022-11-10"};
+TEST(MetadataTests, TestDatasetConditionInfoToString) {
+  const DatasetConditionInfo target{
+      DatasetCondition::Bad,
+      {{"2022-11-07", DatasetCondition::Available},
+       {"2022-11-08", DatasetCondition::Bad},
+       {"2022-11-09", DatasetCondition::Bad},
+       {"2022-11-10", DatasetCondition::Available}},
+      "2022-11-07",
+      "2022-11-10"};
   const auto res = ToString(target);
-  ASSERT_EQ(res, R"(DatasetConditions {
+  ASSERT_EQ(res, R"(DatasetConditionInfo {
     condition = bad,
     details = {
         DatasetConditionDetail { date = "2022-11-07", condition = available },