Enforce naming convention of getters in version_set.h

Summary: Enforce the accessier naming convention in functions in version_set.h

Test Plan: make all check

Reviewers: ljin, yhchiang, rven, igor

Reviewed By: igor

Subscribers: leveldb, dhruba

Differential Revision: https://reviews.facebook.net/D28143

db/column_family.cc

@@ -324,8 +324,8 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
       const MutableCFOptions& mutable_cf_options) {
   if (current_ != nullptr) {
     auto* vstorage = current_->storage_info();
-    const double score = vstorage->MaxCompactionScore();
-    const int max_level = vstorage->MaxCompactionScoreLevel();
+    const double score = vstorage->max_compaction_score();
+    const int max_level = vstorage->max_compaction_score_level();
 
     auto write_controller = column_family_set_->write_controller_;
 

db/compaction_picker.cc

@@ -328,7 +328,7 @@ Compaction* CompactionPicker::CompactRange(
   }
   assert(output_path_id < static_cast<uint32_t>(ioptions_.db_paths.size()));
   Compaction* c = new Compaction(
-      vstorage->NumberLevels(), input_level, output_level,
+      vstorage->num_levels(), input_level, output_level,
       mutable_cf_options.MaxFileSizeForLevel(output_level),
       mutable_cf_options.MaxGrandParentOverlapBytes(input_level),
       output_path_id, GetCompressionType(ioptions_, output_level));
@@ -457,7 +457,7 @@ Compaction* LevelCompactionPicker::PickCompactionBySize(
 
   assert(level >= 0);
   assert(level + 1 < NumberLevels());
-  c = new Compaction(vstorage->NumberLevels(), level, level + 1,
+  c = new Compaction(vstorage->num_levels(), level, level + 1,
                      mutable_cf_options.MaxFileSizeForLevel(level + 1),
                      mutable_cf_options.MaxGrandParentOverlapBytes(level), 0,
                      GetCompressionType(ioptions_, level + 1));
@@ -778,7 +778,7 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalReadAmp(
   uint32_t path_id = GetPathId(ioptions_, estimated_total_size);
 
   Compaction* c = new Compaction(
-      vstorage->NumberLevels(), kLevel0, kLevel0,
+      vstorage->num_levels(), kLevel0, kLevel0,
       mutable_cf_options.MaxFileSizeForLevel(kLevel0), LLONG_MAX, path_id,
       GetCompressionType(ioptions_, kLevel0, enable_compression));
   c->score_ = score;
@@ -898,7 +898,7 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalSizeAmp(
   // create a compaction request
   // We always compact all the files, so always compress.
   Compaction* c =
-      new Compaction(vstorage->NumberLevels(), kLevel, kLevel,
+      new Compaction(vstorage->num_levels(), kLevel, kLevel,
                      mutable_cf_options.MaxFileSizeForLevel(kLevel), LLONG_MAX,
                      path_id, GetCompressionType(ioptions_, kLevel));
   c->score_ = score;
@@ -918,7 +918,7 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalSizeAmp(
 Compaction* FIFOCompactionPicker::PickCompaction(
     const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
     VersionStorageInfo* vstorage, LogBuffer* log_buffer) {
-  assert(vstorage->NumberLevels() == 1);
+  assert(vstorage->num_levels() == 1);
   const int kLevel0 = 0;
   const std::vector<FileMetaData*>& level_files = vstorage->LevelFiles(kLevel0);
   uint64_t total_size = 0;

db/compaction_picker_test.cc

@@ -50,7 +50,7 @@ class CompactionPickerTest {
   }
 
   ~CompactionPickerTest() {
-    for (int i = 0; i < vstorage.NumberLevels(); i++) {
+    for (int i = 0; i < vstorage.num_levels(); i++) {
       for (auto* f : vstorage.LevelFiles(i)) {
         delete f;
       }
@@ -61,7 +61,7 @@ class CompactionPickerTest {
            const char* largest, uint64_t file_size = 0, uint32_t path_id = 0,
            SequenceNumber smallest_seq = 100,
            SequenceNumber largest_seq = 100) {
-    assert(level < vstorage.NumberLevels());
+    assert(level < vstorage.num_levels());
     FileMetaData* f = new FileMetaData;
     f->fd = FileDescriptor(file_number, path_id, file_size);
     f->smallest = InternalKey(smallest, smallest_seq, kTypeValue);

db/db_filesnapshot.cc

@@ -122,10 +122,10 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
   }
 
   ret.push_back(CurrentFileName(""));
-  ret.push_back(DescriptorFileName("", versions_->ManifestFileNumber()));
+  ret.push_back(DescriptorFileName("", versions_->manifest_file_number()));
 
   // find length of manifest file while holding the mutex lock
-  *manifest_file_size = versions_->ManifestFileSize();
+  *manifest_file_size = versions_->manifest_file_size();
 
   mutex_.Unlock();
   return Status::OK();

db/db_impl.cc

@@ -425,11 +425,11 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
   versions_->GetObsoleteFiles(&job_context->sst_delete_files);
 
   // store the current filenum, lognum, etc
-  job_context->manifest_file_number = versions_->ManifestFileNumber();
+  job_context->manifest_file_number = versions_->manifest_file_number();
   job_context->pending_manifest_file_number =
-      versions_->PendingManifestFileNumber();
+      versions_->pending_manifest_file_number();
   job_context->log_number = versions_->MinLogNumber();
-  job_context->prev_log_number = versions_->PrevLogNumber();
+  job_context->prev_log_number = versions_->prev_log_number();
 
   if (!doing_the_full_scan && !job_context->HaveSomethingToDelete()) {
     // avoid filling up sst_live if we're sure that we
@@ -730,11 +730,11 @@ Status DBImpl::Recover(
     // descriptor (new log files may have been added by the previous
     // incarnation without registering them in the descriptor).
     //
-    // Note that PrevLogNumber() is no longer used, but we pay
+    // Note that prev_log_number() is no longer used, but we pay
     // attention to it in case we are recovering a database
     // produced by an older version of rocksdb.
     const uint64_t min_log = versions_->MinLogNumber();
-    const uint64_t prev_log = versions_->PrevLogNumber();
+    const uint64_t prev_log = versions_->prev_log_number();
     std::vector<std::string> filenames;
     s = env_->GetChildren(db_options_.wal_dir, &filenames);
     if (!s.ok()) {
@@ -2729,7 +2729,7 @@ Status DBImpl::SetNewMemtableAndNewLogFile(ColumnFamilyData* cfd,
 
   // Attempt to switch to a new memtable and trigger flush of old.
   // Do this without holding the dbmutex lock.
-  assert(versions_->PrevLogNumber() == 0);
+  assert(versions_->prev_log_number() == 0);
   bool creating_new_log = !log_empty_;
   uint64_t new_log_number =
       creating_new_log ? versions_->NewFileNumber() : logfile_number_;
@@ -3269,7 +3269,7 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
       if (cfd->ioptions()->compaction_style == kCompactionStyleUniversal ||
           cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
         auto* vstorage = cfd->current()->storage_info();
-        for (int i = 1; i < vstorage->NumberLevels(); ++i) {
+        for (int i = 1; i < vstorage->num_levels(); ++i) {
           int num_files = vstorage->NumLevelFiles(i);
           if (num_files > 0) {
             s = Status::InvalidArgument(

db/db_impl_debug.cc

@@ -67,7 +67,7 @@ void DBImpl::TEST_GetFilesMetaData(
 }
 
 uint64_t DBImpl::TEST_Current_Manifest_FileNo() {
-  return versions_->ManifestFileNumber();
+  return versions_->manifest_file_number();
 }
 
 Status DBImpl::TEST_CompactRange(int level, const Slice* begin,

db/db_test.cc

@@ -5776,7 +5776,7 @@ TEST(DBTest, DropWrites) {
     env_->drop_writes_.store(true, std::memory_order_release);
     env_->sleep_counter_.Reset();
     for (int i = 0; i < 5; i++) {
-      for (int level = 0; level < dbfull()->NumberLevels()-1; level++) {
+      for (int level = 0; level < dbfull()->NumberLevels() - 1; level++) {
         dbfull()->TEST_CompactRange(level, nullptr, nullptr);
       }
     }

db/forward_iterator.cc

@@ -249,7 +249,7 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
 
     int32_t search_left_bound = 0;
     int32_t search_right_bound = FileIndexer::kLevelMaxIndex;
-    for (int32_t level = 1; level < vstorage->NumberLevels(); ++level) {
+    for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
       const std::vector<FileMetaData*>& level_files =
           vstorage->LevelFiles(level);
       if (level_files.empty()) {
@@ -259,7 +259,7 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
       }
       assert(level_iters_[level - 1] != nullptr);
       uint32_t f_idx = 0;
-      const auto& indexer = vstorage->GetIndexer();
+      const auto& indexer = vstorage->file_indexer();
       if (!seek_to_first) {
         if (search_left_bound == search_right_bound) {
           f_idx = search_left_bound;
@@ -437,8 +437,8 @@ void ForwardIterator::RebuildIterators(bool refresh_sv) {
     l0_iters_.push_back(cfd_->table_cache()->NewIterator(
         read_options_, *cfd_->soptions(), cfd_->internal_comparator(), l0->fd));
   }
-  level_iters_.reserve(vstorage->NumberLevels() - 1);
-  for (int32_t level = 1; level < vstorage->NumberLevels(); ++level) {
+  level_iters_.reserve(vstorage->num_levels() - 1);
+  for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
     const auto& level_files = vstorage->LevelFiles(level);
 
     if (level_files.empty()) {

db/internal_stats.cc

@@ -371,7 +371,7 @@ void InternalStats::DumpCFStats(std::string* value) {
   int num_levels_to_check =
       (cfd_->options()->compaction_style != kCompactionStyleUniversal &&
        cfd_->options()->compaction_style != kCompactionStyleFIFO)
-          ? vstorage->NumberLevels() - 1
+          ? vstorage->num_levels() - 1
           : 1;
 
   // Compaction scores are sorted base on its value. Restore them to the

db/version_builder.cc

@@ -54,10 +54,7 @@ class VersionBuilder::Rep {
   // kLevel0 -- NewestFirstBySeqNo
   // kLevelNon0 -- BySmallestKey
   struct FileComparator {
-    enum SortMethod {
-      kLevel0 = 0,
-      kLevelNon0 = 1,
-    } sort_method;
+    enum SortMethod { kLevel0 = 0, kLevelNon0 = 1, } sort_method;
     const InternalKeyComparator* internal_comparator;
 
     bool operator()(FileMetaData* f1, FileMetaData* f2) const {
@@ -91,25 +88,25 @@ class VersionBuilder::Rep {
       : env_options_(env_options),
         table_cache_(table_cache),
         base_vstorage_(base_vstorage) {
-    levels_ = new LevelState[base_vstorage_->NumberLevels()];
+    levels_ = new LevelState[base_vstorage_->num_levels()];
     level_zero_cmp_.sort_method = FileComparator::kLevel0;
     level_nonzero_cmp_.sort_method = FileComparator::kLevelNon0;
     level_nonzero_cmp_.internal_comparator =
         base_vstorage_->InternalComparator();
 
     levels_[0].added_files = new FileSet(level_zero_cmp_);
-    for (int level = 1; level < base_vstorage_->NumberLevels(); level++) {
-        levels_[level].added_files = new FileSet(level_nonzero_cmp_);
+    for (int level = 1; level < base_vstorage_->num_levels(); level++) {
+      levels_[level].added_files = new FileSet(level_nonzero_cmp_);
     }
   }
 
   ~Rep() {
-    for (int level = 0; level < base_vstorage_->NumberLevels(); level++) {
+    for (int level = 0; level < base_vstorage_->num_levels(); level++) {
       const FileSet* added = levels_[level].added_files;
       std::vector<FileMetaData*> to_unref;
       to_unref.reserve(added->size());
-      for (FileSet::const_iterator it = added->begin();
-          it != added->end(); ++it) {
+      for (FileSet::const_iterator it = added->begin(); it != added->end();
+           ++it) {
         to_unref.push_back(*it);
       }
       delete added;
@@ -133,7 +130,7 @@ class VersionBuilder::Rep {
   void CheckConsistency(VersionStorageInfo* vstorage) {
 #ifndef NDEBUG
     // make sure the files are sorted correctly
-    for (int level = 0; level < vstorage->NumberLevels(); level++) {
+    for (int level = 0; level < vstorage->num_levels(); level++) {
       auto& level_files = vstorage->LevelFiles(level);
       for (size_t i = 1; i < level_files.size(); i++) {
         auto f1 = level_files[i - 1];
@@ -161,51 +158,50 @@ class VersionBuilder::Rep {
   void CheckConsistencyForDeletes(VersionEdit* edit, uint64_t number,
                                   int level) {
 #ifndef NDEBUG
-      // a file to be deleted better exist in the previous version
-      bool found = false;
-      for (int l = 0; !found && l < base_vstorage_->NumberLevels(); l++) {
-        const std::vector<FileMetaData*>& base_files =
-            base_vstorage_->LevelFiles(l);
-        for (unsigned int i = 0; i < base_files.size(); i++) {
-          FileMetaData* f = base_files[i];
-          if (f->fd.GetNumber() == number) {
-            found =  true;
-            break;
-          }
+    // a file to be deleted better exist in the previous version
+    bool found = false;
+    for (int l = 0; !found && l < base_vstorage_->num_levels(); l++) {
+      const std::vector<FileMetaData*>& base_files =
+          base_vstorage_->LevelFiles(l);
+      for (unsigned int i = 0; i < base_files.size(); i++) {
+        FileMetaData* f = base_files[i];
+        if (f->fd.GetNumber() == number) {
+          found = true;
+          break;
         }
       }
-      // if the file did not exist in the previous version, then it
-      // is possibly moved from lower level to higher level in current
-      // version
-      for (int l = level + 1; !found && l < base_vstorage_->NumberLevels();
-           l++) {
-        const FileSet* added = levels_[l].added_files;
-        for (FileSet::const_iterator added_iter = added->begin();
-             added_iter != added->end(); ++added_iter) {
-          FileMetaData* f = *added_iter;
-          if (f->fd.GetNumber() == number) {
-            found = true;
-            break;
-          }
+    }
+    // if the file did not exist in the previous version, then it
+    // is possibly moved from lower level to higher level in current
+    // version
+    for (int l = level + 1; !found && l < base_vstorage_->num_levels(); l++) {
+      const FileSet* added = levels_[l].added_files;
+      for (FileSet::const_iterator added_iter = added->begin();
+           added_iter != added->end(); ++added_iter) {
+        FileMetaData* f = *added_iter;
+        if (f->fd.GetNumber() == number) {
+          found = true;
+          break;
         }
       }
+    }
 
-      // maybe this file was added in a previous edit that was Applied
-      if (!found) {
-        const FileSet* added = levels_[level].added_files;
-        for (FileSet::const_iterator added_iter = added->begin();
-             added_iter != added->end(); ++added_iter) {
-          FileMetaData* f = *added_iter;
-          if (f->fd.GetNumber() == number) {
-            found = true;
-            break;
-          }
+    // maybe this file was added in a previous edit that was Applied
+    if (!found) {
+      const FileSet* added = levels_[level].added_files;
+      for (FileSet::const_iterator added_iter = added->begin();
+           added_iter != added->end(); ++added_iter) {
+        FileMetaData* f = *added_iter;
+        if (f->fd.GetNumber() == number) {
+          found = true;
+          break;
         }
       }
-      if (!found) {
-        fprintf(stderr, "not found %" PRIu64 "\n", number);
-      }
-      assert(found);
+    }
+    if (!found) {
+      fprintf(stderr, "not found %" PRIu64 "\n", number);
+    }
+    assert(found);
 #endif
   }
 
@@ -238,7 +234,7 @@ class VersionBuilder::Rep {
     CheckConsistency(base_vstorage_);
     CheckConsistency(vstorage);
 
-    for (int level = 0; level < base_vstorage_->NumberLevels(); level++) {
+    for (int level = 0; level < base_vstorage_->num_levels(); level++) {
       const auto& cmp = (level == 0) ? level_zero_cmp_ : level_nonzero_cmp_;
       // Merge the set of added files with the set of pre-existing files.
       // Drop any deleted files.  Store the result in *v.
@@ -251,8 +247,7 @@ class VersionBuilder::Rep {
       for (const auto& added : added_files) {
         // Add all smaller files listed in base_
         for (auto bpos = std::upper_bound(base_iter, base_end, added, cmp);
-             base_iter != bpos;
-             ++base_iter) {
+             base_iter != bpos; ++base_iter) {
           MaybeAddFile(vstorage, level, *base_iter);
         }
 
@@ -270,7 +265,7 @@ class VersionBuilder::Rep {
 
   void LoadTableHandlers() {
     assert(table_cache_ != nullptr);
-    for (int level = 0; level < base_vstorage_->NumberLevels(); level++) {
+    for (int level = 0; level < base_vstorage_->num_levels(); level++) {
       for (auto& file_meta : *(levels_[level].added_files)) {
         assert(!file_meta->table_reader_handle);
         table_cache_->FindTable(
@@ -280,10 +275,10 @@ class VersionBuilder::Rep {
           // Load table_reader
           file_meta->fd.table_reader = table_cache_->GetTableReaderFromHandle(
               file_meta->table_reader_handle);
+        }
       }
     }
   }
-  }
 
   void MaybeAddFile(VersionStorageInfo* vstorage, int level, FileMetaData* f) {
     if (levels_[level].deleted_files.count(f->fd.GetNumber()) > 0) {

db/version_builder_test.cc

@@ -37,7 +37,7 @@ class VersionBuilderTest {
   }
 
   ~VersionBuilderTest() {
-    for (int i = 0; i < vstorage.NumberLevels(); i++) {
+    for (int i = 0; i < vstorage.num_levels(); i++) {
       for (auto* f : vstorage.LevelFiles(i)) {
         if (--f->refs == 0) {
           delete f;
@@ -55,7 +55,7 @@ class VersionBuilderTest {
            const char* largest, uint64_t file_size = 0, uint32_t path_id = 0,
            SequenceNumber smallest_seq = 100,
            SequenceNumber largest_seq = 100) {
-    assert(level < vstorage.NumberLevels());
+    assert(level < vstorage.num_levels());
     FileMetaData* f = new FileMetaData;
     f->fd = FileDescriptor(file_number, path_id, file_size);
     f->smallest = GetInternalKey(smallest, smallest_seq);
@@ -109,7 +109,7 @@ TEST(VersionBuilderTest, ApplyAndSaveTo) {
   ASSERT_EQ(400U, new_vstorage.NumLevelBytes(2));
   ASSERT_EQ(300U, new_vstorage.NumLevelBytes(3));
 
-  for (int i = 0; i < new_vstorage.NumberLevels(); i++) {
+  for (int i = 0; i < new_vstorage.num_levels(); i++) {
     for (auto* f : new_vstorage.LevelFiles(i)) {
       if (--f->refs == 0) {
         delete f;

db/version_set.cc

@@ -499,7 +499,7 @@ class BaseReferencedVersionBuilder {
  public:
   explicit BaseReferencedVersionBuilder(ColumnFamilyData* cfd)
       : version_builder_(new VersionBuilder(
-            cfd->current()->version_set()->GetEnvOptions(), cfd->table_cache(),
+            cfd->current()->version_set()->env_options(), cfd->table_cache(),
             cfd->current()->storage_info())),
         version_(cfd->current()) {
     version_->Ref();
@@ -508,7 +508,7 @@ class BaseReferencedVersionBuilder {
     delete version_builder_;
     version_->Unref();
   }
-  VersionBuilder* GetVersionBuilder() { return version_builder_; }
+  VersionBuilder* version_builder() { return version_builder_; }
 
  private:
   VersionBuilder* version_builder_;
@@ -635,7 +635,7 @@ void Version::AddIterators(const ReadOptions& read_options,
   // For levels > 0, we can use a concatenating iterator that sequentially
   // walks through the non-overlapping files in the level, opening them
   // lazily.
-  for (int level = 1; level < storage_info_.NumberLevels(); level++) {
+  for (int level = 1; level < storage_info_.num_levels(); level++) {
     if (storage_info_.level_files_brief_[level].num_files != 0) {
       merge_iter_builder->AddIterator(NewTwoLevelIterator(
           new LevelFileIteratorState(
@@ -892,7 +892,7 @@ void VersionStorageInfo::ComputeCompensatedSizes() {
 
 int VersionStorageInfo::MaxInputLevel() const {
   if (compaction_style_ == kCompactionStyleLevel) {
-    return NumberLevels() - 2;
+    return num_levels() - 2;
   }
   return 0;
 }
@@ -960,8 +960,8 @@ void VersionStorageInfo::ComputeCompactionScore(
 
   // sort all the levels based on their score. Higher scores get listed
   // first. Use bubble sort because the number of entries are small.
-  for (int i = 0; i < NumberLevels() - 2; i++) {
-    for (int j = i + 1; j < NumberLevels() - 1; j++) {
+  for (int i = 0; i < num_levels() - 2; i++) {
+    for (int j = i + 1; j < num_levels() - 1; j++) {
       if (compaction_score_[i] < compaction_score_[j]) {
         double score = compaction_score_[i];
         int level = compaction_level_[i];
@@ -992,7 +992,7 @@ bool CompareCompensatedSizeDescending(const Fsize& first, const Fsize& second) {
 } // anonymous namespace
 
 void VersionStorageInfo::MaybeAddFile(int level, FileMetaData* f) {
-  assert(level < NumberLevels());
+  assert(level < num_levels());
   auto* level_files = &files_[level];
   // Must not overlap
   assert(level <= 0 || level_files->empty() ||
@@ -1021,7 +1021,7 @@ void VersionStorageInfo::UpdateFilesBySize() {
     return;
   }
   // No need to sort the highest level because it is never compacted.
-  for (int level = 0; level < NumberLevels() - 1; level++) {
+  for (int level = 0; level < num_levels() - 1; level++) {
     const std::vector<FileMetaData*>& files = files_[level];
     auto& files_by_size = files_by_size_[level];
     assert(files_by_size.size() == 0);
@@ -1335,14 +1335,14 @@ bool VersionStorageInfo::HasOverlappingUserKey(
 
 uint64_t VersionStorageInfo::NumLevelBytes(int level) const {
   assert(level >= 0);
-  assert(level < NumberLevels());
+  assert(level < num_levels());
   return TotalFileSize(files_[level]);
 }
 
 const char* VersionStorageInfo::LevelSummary(
     LevelSummaryStorage* scratch) const {
   int len = snprintf(scratch->buffer, sizeof(scratch->buffer), "files[");
-  for (int i = 0; i < NumberLevels(); i++) {
+  for (int i = 0; i < num_levels(); i++) {
     int sz = sizeof(scratch->buffer) - len;
     int ret = snprintf(scratch->buffer + len, sz, "%d ", int(files_[i].size()));
     if (ret < 0 || ret >= sz) break;
@@ -1382,7 +1382,7 @@ const char* VersionStorageInfo::LevelFileSummary(FileSummaryStorage* scratch,
 int64_t VersionStorageInfo::MaxNextLevelOverlappingBytes() {
   uint64_t result = 0;
   std::vector<FileMetaData*> overlaps;
-  for (int level = 1; level < NumberLevels() - 1; level++) {
+  for (int level = 1; level < num_levels() - 1; level++) {
     for (const auto& f : files_[level]) {
       GetOverlappingInputs(level + 1, &f->smallest, &f->largest, &overlaps);
       const uint64_t sum = TotalFileSize(overlaps);
@@ -1395,7 +1395,7 @@ int64_t VersionStorageInfo::MaxNextLevelOverlappingBytes() {
 }
 
 void Version::AddLiveFiles(std::vector<FileDescriptor>* live) {
-  for (int level = 0; level < storage_info_.NumberLevels(); level++) {
+  for (int level = 0; level < storage_info_.num_levels(); level++) {
     const std::vector<FileMetaData*>& files = storage_info_.files_[level];
     for (const auto& file : files) {
       live->push_back(file->fd);
@@ -1544,7 +1544,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
   } else {
     v = new Version(column_family_data, this, current_version_number_++);
     builder_guard.reset(new BaseReferencedVersionBuilder(column_family_data));
-    auto* builder = builder_guard->GetVersionBuilder();
+    auto* builder = builder_guard->version_builder();
     for (const auto& writer : manifest_writers_) {
       if (writer->edit->IsColumnFamilyManipulation() ||
           writer->cfd->GetID() != column_family_data->GetID()) {
@@ -1586,7 +1586,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
   {
     std::vector<uint64_t> size_being_compacted;
     if (!edit->IsColumnFamilyManipulation()) {
-      size_being_compacted.resize(v->storage_info()->NumberLevels() - 1);
+      size_being_compacted.resize(v->storage_info()->num_levels() - 1);
       // calculate the amount of data being compacted at every level
       column_family_data->compaction_picker()->SizeBeingCompacted(
           size_being_compacted);
@@ -1598,7 +1598,7 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
         db_options_->max_open_files == -1) {
       // unlimited table cache. Pre-load table handle now.
       // Need to do it out of the mutex.
-      builder_guard->GetVersionBuilder()->LoadTableHandlers();
+      builder_guard->version_builder()->LoadTableHandlers();
     }
 
     // This is fine because everything inside of this block is serialized --
@@ -1947,7 +1947,7 @@ Status VersionSet::Recover(
         cfd = column_family_set_->GetColumnFamily(edit.column_family_);
         // this should never happen since cf_in_builders is true
         assert(cfd != nullptr);
-        if (edit.max_level_ >= cfd->current()->storage_info()->NumberLevels()) {
+        if (edit.max_level_ >= cfd->current()->storage_info()->num_levels()) {
           s = Status::InvalidArgument(
               "db has more levels than options.num_levels");
           break;
@@ -1958,7 +1958,7 @@ Status VersionSet::Recover(
         // to builder
         auto builder = builders.find(edit.column_family_);
         assert(builder != builders.end());
-        builder->second->GetVersionBuilder()->Apply(&edit);
+        builder->second->version_builder()->Apply(&edit);
       }
 
       if (cfd != nullptr) {
@@ -2038,7 +2038,7 @@ Status VersionSet::Recover(
     for (auto cfd : *column_family_set_) {
       auto builders_iter = builders.find(cfd->GetID());
       assert(builders_iter != builders.end());
-      auto* builder = builders_iter->second->GetVersionBuilder();
+      auto* builder = builders_iter->second->version_builder();
 
       if (db_options_->max_open_files == -1) {
       // unlimited table cache. Pre-load table handle now.
@@ -2051,7 +2051,7 @@ Status VersionSet::Recover(
 
       // Install recovered version
       std::vector<uint64_t> size_being_compacted(
-          v->storage_info()->NumberLevels() - 1);
+          v->storage_info()->num_levels() - 1);
       cfd->compaction_picker()->SizeBeingCompacted(size_being_compacted);
       v->PrepareApply(*cfd->GetLatestMutableCFOptions(), size_being_compacted);
       AppendVersion(cfd, v);
@@ -2184,7 +2184,7 @@ Status VersionSet::ReduceNumberOfLevels(const std::string& dbname,
   Version* current_version =
       versions.GetColumnFamilySet()->GetDefault()->current();
   auto* vstorage = current_version->storage_info();
-  int current_levels = vstorage->NumberLevels();
+  int current_levels = vstorage->num_levels();
 
   if (current_levels <= new_levels) {
     return Status::OK();
@@ -2335,7 +2335,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
         // to builder
         auto builder = builders.find(edit.column_family_);
         assert(builder != builders.end());
-        builder->second->GetVersionBuilder()->Apply(&edit);
+        builder->second->version_builder()->Apply(&edit);
       }
 
       if (cfd != nullptr && edit.has_log_number_) {
@@ -2382,12 +2382,12 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
     for (auto cfd : *column_family_set_) {
       auto builders_iter = builders.find(cfd->GetID());
       assert(builders_iter != builders.end());
-      auto builder = builders_iter->second->GetVersionBuilder();
+      auto builder = builders_iter->second->version_builder();
 
       Version* v = new Version(cfd, this, current_version_number_++);
       builder->SaveTo(v->storage_info());
       std::vector<uint64_t> size_being_compacted(
-          v->storage_info()->NumberLevels() - 1);
+          v->storage_info()->num_levels() - 1);
       cfd->compaction_picker()->SizeBeingCompacted(size_being_compacted);
       v->PrepareApply(*cfd->GetLatestMutableCFOptions(), size_being_compacted);
       delete builder;
@@ -2521,7 +2521,7 @@ bool VersionSet::ManifestContains(uint64_t manifest_file_number,
 uint64_t VersionSet::ApproximateOffsetOf(Version* v, const InternalKey& ikey) {
   uint64_t result = 0;
   const auto* vstorage = v->storage_info();
-  for (int level = 0; level < vstorage->NumberLevels(); level++) {
+  for (int level = 0; level < vstorage->num_levels(); level++) {
     const std::vector<FileMetaData*>& files = vstorage->LevelFiles(level);
     for (size_t i = 0; i < files.size(); i++) {
       if (v->cfd_->internal_comparator().Compare(files[i]->largest, ikey) <=
@@ -2562,7 +2562,7 @@ void VersionSet::AddLiveFiles(std::vector<FileDescriptor>* live_list) {
     for (Version* v = dummy_versions->next_; v != dummy_versions;
          v = v->next_) {
       const auto* vstorage = v->storage_info();
-      for (int level = 0; level < vstorage->NumberLevels(); level++) {
+      for (int level = 0; level < vstorage->num_levels(); level++) {
         total_files += vstorage->LevelFiles(level).size();
       }
     }
@@ -2576,7 +2576,7 @@ void VersionSet::AddLiveFiles(std::vector<FileDescriptor>* live_list) {
     for (Version* v = dummy_versions->next_; v != dummy_versions;
          v = v->next_) {
       const auto* vstorage = v->storage_info();
-      for (int level = 0; level < vstorage->NumberLevels(); level++) {
+      for (int level = 0; level < vstorage->num_levels(); level++) {
         for (const auto& f : vstorage->LevelFiles(level)) {
           live_list->push_back(f->fd);
         }
@@ -2686,7 +2686,7 @@ Status VersionSet::GetMetadataForFile(uint64_t number, int* filelevel,
   for (auto cfd_iter : *column_family_set_) {
     Version* version = cfd_iter->current();
     const auto* vstorage = version->storage_info();
-    for (int level = 0; level < vstorage->NumberLevels(); level++) {
+    for (int level = 0; level < vstorage->num_levels(); level++) {
       for (const auto& file : vstorage->LevelFiles(level)) {
         if (file->fd.GetNumber() == number) {
           *meta = file;

db/version_set.h

@@ -132,10 +132,10 @@ class VersionStorageInfo {
   bool NeedsCompaction() const;
 
   // Returns the maxmimum compaction score for levels 1 to max
-  double MaxCompactionScore() const { return max_compaction_score_; }
+  double max_compaction_score() const { return max_compaction_score_; }
 
   // See field declaration
-  int MaxCompactionScoreLevel() const { return max_compaction_score_level_; }
+  int max_compaction_score_level() const { return max_compaction_score_level_; }
 
   // Return level number that has idx'th highest score
   int CompactionScoreLevel(int idx) const { return compaction_level_[idx]; }
@@ -183,10 +183,10 @@ class VersionStorageInfo {
                                  const Slice& smallest_user_key,
                                  const Slice& largest_user_key);
 
-  int NumberLevels() const { return num_levels_; }
+  int num_levels() const { return num_levels_; }
 
   // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  int NumNonEmptyLevels() const {
+  int num_non_empty_levels() const {
     assert(finalized_);
     return num_non_empty_levels_;
   }
@@ -228,7 +228,7 @@ class VersionStorageInfo {
   }
 
   // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  const FileIndexer& GetIndexer() const {
+  const FileIndexer& file_indexer() const {
     assert(finalized_);
     return file_indexer_;
   }
@@ -524,9 +524,9 @@ class VersionSet {
 #endif  // ROCKSDB_LITE
 
   // Return the current manifest file number
-  uint64_t ManifestFileNumber() const { return manifest_file_number_; }
+  uint64_t manifest_file_number() const { return manifest_file_number_; }
 
-  uint64_t PendingManifestFileNumber() const {
+  uint64_t pending_manifest_file_number() const {
     return pending_manifest_file_number_;
   }
 
@@ -558,7 +558,7 @@ class VersionSet {
 
   // Return the log file number for the log file that is currently
   // being compacted, or zero if there is no such log file.
-  uint64_t PrevLogNumber() const { return prev_log_number_; }
+  uint64_t prev_log_number() const { return prev_log_number_; }
 
   // Returns the minimum log number such that all
   // log numbers less than or equal to it can be deleted
@@ -584,7 +584,7 @@ class VersionSet {
   uint64_t ApproximateOffsetOf(Version* v, const InternalKey& key);
 
   // Return the size of the current manifest file
-  uint64_t ManifestFileSize() const { return manifest_file_size_; }
+  uint64_t manifest_file_size() const { return manifest_file_size_; }
 
   // verify that the files that we started with for a compaction
   // still exist in the current version and in the same original level.
@@ -600,7 +600,7 @@ class VersionSet {
   void GetObsoleteFiles(std::vector<FileMetaData*>* files);
 
   ColumnFamilySet* GetColumnFamilySet() { return column_family_set_.get(); }
-  const EnvOptions& GetEnvOptions() { return env_options_; }
+  const EnvOptions& env_options() { return env_options_; }
 
  private:
   struct ManifestWriter;

utilities/compacted_db/compacted_db_impl.cc

@@ -111,20 +111,20 @@ Status CompactedDBImpl::Init(const Options& options) {
     return Status::NotSupported("L0 contain more than 1 file");
   }
   if (l0.num_files == 1) {
-    if (vstorage->NumNonEmptyLevels() > 1) {
+    if (vstorage->num_non_empty_levels() > 1) {
       return Status::NotSupported("Both L0 and other level contain files");
     }
     files_ = l0;
     return Status::OK();
   }
 
-  for (int i = 1; i < vstorage->NumNonEmptyLevels() - 1; ++i) {
+  for (int i = 1; i < vstorage->num_non_empty_levels() - 1; ++i) {
     if (vstorage->LevelFilesBrief(i).num_files > 0) {
       return Status::NotSupported("Other levels also contain files");
     }
   }
 
-  int level = vstorage->NumNonEmptyLevels() - 1;
+  int level = vstorage->num_non_empty_levels() - 1;
   if (vstorage->LevelFilesBrief(level).num_files > 0) {
     files_ = vstorage->LevelFilesBrief(level);
     return Status::OK();