internal_repo_rocksdb (2794583611362153785)

Differential Revision: D52559771

db/db_info_dumper.cc

@@ -5,7 +5,7 @@
 
 #include "db/db_info_dumper.h"
 
-#include <stdio.h>
+#include <cstdio>
 
 #include <algorithm>
 #include <cinttypes>

db/db_iter_stress_test.cc

@@ -50,7 +50,8 @@ struct Entry {
   bool visible = true;
 
   bool operator<(const Entry& e) const {
-    if (key != e.key) return key < e.key;
+    if (key != e.key) { return key < e.key;
+}
     return std::tie(sequence, type) > std::tie(e.sequence, e.type);
   }
 };
@@ -177,15 +178,17 @@ struct StressTestIterator : public InternalIterator {
   }
 
   void SeekToFirst() override {
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
 
     status_ = Status::OK();
     iter = 0;
     SkipForward();
   }
   void SeekToLast() override {
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
 
     status_ = Status::OK();
@@ -194,7 +197,8 @@ struct StressTestIterator : public InternalIterator {
   }
 
   void Seek(const Slice& target) override {
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
 
     status_ = Status::OK();
@@ -206,7 +210,8 @@ struct StressTestIterator : public InternalIterator {
     SkipForward();
   }
   void SeekForPrev(const Slice& target) override {
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
 
     status_ = Status::OK();
@@ -221,14 +226,16 @@ struct StressTestIterator : public InternalIterator {
 
   void Next() override {
     assert(Valid());
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
     ++iter;
     SkipForward();
   }
   void Prev() override {
     assert(Valid());
-    if (MaybeFail()) return;
+    if (MaybeFail()) { return;
+}
     MaybeMutate();
     --iter;
     SkipBackward();
@@ -318,7 +325,8 @@ struct ReferenceIterator {
         return false;
       }
       assert(e.sequence <= sequence);
-      if (!e.visible) continue;
+      if (!e.visible) { continue;
+}
       if (e.type == kTypeDeletion) {
         return false;
       }
@@ -339,11 +347,12 @@ struct ReferenceIterator {
         break;
       }
       assert(e.sequence <= sequence);
-      if (!e.visible) continue;
+      if (!e.visible) { continue;
+}
       if (e.type == kTypeDeletion) {
         break;
       }
-      operands.push_back(e.value);
+      operands.emplace_back(e.value);
       if (e.type == kTypeValue) {
         break;
       }
@@ -588,15 +597,17 @@ TEST_F(DBIteratorStressTest, StressTest) {
 
                     // Check that the key moved in the right direction.
                     if (forward) {
-                      if (seek)
+                      if (seek) {
                         ASSERT_GE(db_iter->key().ToString(), old_key);
-                      else
+                      } else {
                         ASSERT_GT(db_iter->key().ToString(), old_key);
+}
                     } else {
-                      if (seek)
+                      if (seek) {
                         ASSERT_LE(db_iter->key().ToString(), old_key);
-                      else
+                      } else {
                         ASSERT_LT(db_iter->key().ToString(), old_key);
+}
                     }
 
                     if (ref_iter->Valid()) {

db/db_iter_test.cc

@@ -65,8 +65,7 @@ class TestIterator : public InternalIterator {
            size_t seq_num, bool update_iter = false) {
     valid_ = true;
     ParsedInternalKey internal_key(argkey, seq_num, type);
-    data_.push_back(
-        std::pair<std::string, std::string>(std::string(), argvalue));
+    data_.emplace_back(std::string(), argvalue);
     AppendInternalKey(&data_.back().first, internal_key);
     if (update_iter && valid_ && cmp.Compare(data_.back().first, key()) < 0) {
       // insert a key smaller than current key
@@ -2617,7 +2616,7 @@ class DBIterWithMergeIterTest : public testing::Test {
     child_iters.push_back(internal_iter2_);
     InternalKeyComparator icomp(BytewiseComparator());
     InternalIterator* merge_iter =
-        NewMergingIterator(&icomp_, &child_iters[0], 2u);
+        NewMergingIterator(&icomp_, child_iters.data(), 2u);
 
     db_iter_.reset(NewDBIterator(
         env_, ro_, ImmutableOptions(options_), MutableCFOptions(options_),

db/db_iterator_test.cc

@@ -86,7 +86,7 @@ TEST_F(DBIteratorBaseTest, APICallsWithPerfContext) {
 class DBIteratorTest : public DBIteratorBaseTest,
                        public testing::WithParamInterface<bool> {
  public:
-  DBIteratorTest() {}
+  DBIteratorTest() = default;
 
   Iterator* NewIterator(const ReadOptions& read_options,
                         ColumnFamilyHandle* column_family = nullptr) {

db/db_kv_checksum_test.cc

@@ -658,7 +658,7 @@ TEST_F(DbKVChecksumWALToWriteBatchTest, WriteBatchChecksumHandoff) {
   Options options = CurrentOptions();
   Reopen(options);
   ASSERT_OK(db_->Put(WriteOptions(), "key", "val"));
-  std::string content = "";
+  std::string content;
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::RecoverLogFiles:BeforeUpdateProtectionInfo:batch",
       [&](void* batch_ptr) {

db/db_options_test.cc

@@ -1146,11 +1146,11 @@ TEST_F(DBOptionsTest, OffpeakTimes) {
       "1:0000000000000-2:000000000042",  // Weird, but we can parse the int.
   };
 
-  for (std::string invalid_case : invalid_cases) {
+  for (const std::string& invalid_case : invalid_cases) {
     options.daily_offpeak_time_utc = invalid_case;
     verify_invalid();
   }
-  for (std::string valid_case : valid_cases) {
+  for (const std::string& valid_case : valid_cases) {
     options.daily_offpeak_time_utc = valid_case;
     verify_valid();
   }

db/db_properties_test.cc

@@ -7,7 +7,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-#include <stdio.h>
+#include <cstdio>
 
 #include <algorithm>
 #include <string>

db/db_range_del_test.cc

@@ -22,7 +22,7 @@ class DBRangeDelTest : public DBTestBase {
     uint64_t uint64_key = static_cast<uint64_t>(key);
     std::string str;
     str.resize(8);
-    memcpy(&str[0], static_cast<void*>(&uint64_key), 8);
+    memcpy(str.data(), static_cast<void*>(&uint64_key), 8);
     return str;
   }
 };

db/db_secondary_test.cc

@@ -103,7 +103,7 @@ void DBSecondaryTestBase::CheckFileTypeCounts(const std::string& dir,
   ASSERT_OK(env_->GetChildren(dir, &filenames));
 
   int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
-  for (auto file : filenames) {
+  for (const auto& file : filenames) {
     uint64_t number;
     FileType type;
     if (ParseFileName(file, &number, &type)) {

db/db_sst_test.cc

@@ -27,8 +27,8 @@ class DBSSTTest : public DBTestBase {
 // A class which remembers the name of each flushed file.
 class FlushedFileCollector : public EventListener {
  public:
-  FlushedFileCollector() {}
-  ~FlushedFileCollector() override {}
+  FlushedFileCollector() = default;
+  ~FlushedFileCollector() override = default;
 
   void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
     std::lock_guard<std::mutex> lock(mutex_);
@@ -38,7 +38,7 @@ class FlushedFileCollector : public EventListener {
   std::vector<std::string> GetFlushedFiles() {
     std::lock_guard<std::mutex> lock(mutex_);
     std::vector<std::string> result;
-    for (auto fname : flushed_files_) {
+    for (const auto& fname : flushed_files_) {
       result.push_back(fname);
     }
     return result;
@@ -661,7 +661,7 @@ class DBSSTTestRateLimit : public DBSSTTest,
                            public ::testing::WithParamInterface<bool> {
  public:
   DBSSTTestRateLimit() : DBSSTTest() {}
-  ~DBSSTTestRateLimit() override {}
+  ~DBSSTTestRateLimit() override = default;
 };
 
 TEST_P(DBSSTTestRateLimit, RateLimitedDelete) {
@@ -1093,10 +1093,10 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
   int num_wal_files = 0;
   std::vector<std::string> db_files;
   ASSERT_OK(env_->GetChildren(dbname_, &db_files));
-  for (std::string f : db_files) {
-    if (f.substr(f.find_last_of(".") + 1) == "sst") {
+  for (const std::string& f : db_files) {
+    if (f.substr(f.find_last_of('.') + 1) == "sst") {
       num_sst_files++;
-    } else if (f.substr(f.find_last_of(".") + 1) == "log") {
+    } else if (f.substr(f.find_last_of('.') + 1) == "log") {
       num_wal_files++;
     }
   }

db/db_table_properties_test.cc

@@ -246,7 +246,7 @@ DBTablePropertiesTest::TestGetPropertiesOfTablesInRange(
   // run the query
   TablePropertiesCollection props;
   EXPECT_OK(db_->GetPropertiesOfTablesInRange(
-      db_->DefaultColumnFamily(), &ranges[0], ranges.size(), &props));
+      db_->DefaultColumnFamily(), ranges.data(), ranges.size(), &props));
 
   // Make sure that we've received properties for those and for those files
   // only which fall within requested ranges
@@ -363,7 +363,7 @@ TEST_F(DBTablePropertiesTest, GetPropertiesOfTablesInRange) {
     std::vector<Range> ranges;
     auto it = random_keys.begin();
     while (it != random_keys.end()) {
-      ranges.push_back(Range(*it, *(it + 1)));
+      ranges.emplace_back(*it, *(it + 1));
       it += 2;
     }
 
@@ -453,7 +453,7 @@ TEST_F(DBTablePropertiesTest, FactoryReturnsNull) {
       std::make_shared<SometimesTablePropertiesCollectorFactory>());
   // For plain table
   options.prefix_extractor.reset(NewFixedPrefixTransform(4));
-  for (std::shared_ptr<TableFactory> tf :
+  for (const std::shared_ptr<TableFactory>& tf :
        {options.table_factory,
         std::shared_ptr<TableFactory>(NewPlainTableFactory({}))}) {
     SCOPED_TRACE("Table factory = " + std::string(tf->Name()));

db/db_tailing_iter_test.cc

@@ -360,8 +360,9 @@ TEST_P(DBTestTailingIterator, TailingIteratorDeletes) {
 
     // make sure we can read all new records using the existing iterator
     int count = 0;
-    for (; iter->Valid(); iter->Next(), ++count)
+    for (; iter->Valid(); iter->Next(), ++count) {
       ;
+}
     ASSERT_OK(iter->status());
     ASSERT_EQ(count, num_records);
   }