for clang-tidy

src/limestone/datastore.cpp

@@ -55,14 +55,14 @@ datastore::datastore(configuration const& conf) : location_(conf.data_locations_
     epoch_file_path_ = location_ / boost::filesystem::path(std::string(epoch_file_name));
     const bool result = boost::filesystem::exists(epoch_file_path_, error);
     if (!result || error) {
-        FILE* strm = fopen(epoch_file_path_.c_str(), "a");  // NOLINT(*-owning-memory)
+        FILE* strm = fopen(epoch_file_path_.c_str(), "a");  // LINT(*-owning-memory)
         if (!strm) {
             LOG_LP(ERROR) << "does not have write permission for the log_location directory, path: " <<  location_;
             throw std::runtime_error("does not have write permission for the log_location directory");
         }
-        if (fclose(strm) != 0) {  // NOLINT(*-owning-memory)
+        if (fclose(strm) != 0) {  // LINT(*-owning-memory)
             LOG_LP(ERROR) << "fclose failed, errno = " << errno;
-            throw std::runtime_error("I/O error");  //NOLINT
+            throw std::runtime_error("I/O error");  // LINT
         }
         add_file(epoch_file_path_);
     }
@@ -118,7 +118,7 @@ void datastore::switch_epoch(epoch_id_type new_epoch_id) noexcept {
     update_min_epoch_id(true);
 }
 
-void datastore::update_min_epoch_id(bool from_switch_epoch) noexcept {  // NOLINT(readability-function-cognitive-complexity)
+void datastore::update_min_epoch_id(bool from_switch_epoch) noexcept {  // LINT(readability-function-cognitive-complexity)
     auto upper_limit = epoch_id_switched_.load() - 1;
     epoch_id_type max_finished_epoch = 0;
 
@@ -146,7 +146,7 @@ void datastore::update_min_epoch_id(bool from_switch_epoch) noexcept {  // NOLIN
         if (epoch_id_recorded_.compare_exchange_strong(old_epoch_id, to_be_epoch)) {
             std::lock_guard<std::mutex> lock(mtx_epoch_file_);
 
-            FILE* strm = fopen(epoch_file_path_.c_str(), "a");  // NOLINT(*-owning-memory)
+            FILE* strm = fopen(epoch_file_path_.c_str(), "a");  // LINT(*-owning-memory)
             if (!strm) {
                 LOG_LP(ERROR) << "fopen failed, errno = " << errno;
                 std::abort();
@@ -160,7 +160,7 @@ void datastore::update_min_epoch_id(bool from_switch_epoch) noexcept {  // NOLIN
                 LOG_LP(ERROR) << "fsync failed, errno = " << errno;
                 std::abort();
             }
-            if (fclose(strm) != 0) {  // NOLINT(*-owning-memory)
+            if (fclose(strm) != 0) {  // LINT(*-owning-memory)
                 LOG_LP(ERROR) << "fclose failed, errno = " << errno;
                 std::abort();
             }
@@ -213,7 +213,7 @@ backup& datastore::begin_backup() {
     return *backup_;
 }
 
-std::unique_ptr<backup_detail> datastore::begin_backup(backup_type btype) {  // NOLINT(readability-function-cognitive-complexity)
+std::unique_ptr<backup_detail> datastore::begin_backup(backup_type btype) {  // LINT(readability-function-cognitive-complexity)
     rotate_log_files();
 
     // LOG-0: all files are log file, so all files are selected in both standard/transaction mode.

src/limestone/datastore_snapshot.cpp

@@ -77,8 +77,8 @@ epoch_id_type datastore::last_durable_epoch_in_dir() noexcept {
 
 [[maybe_unused]]
 static void store_bswap64_value(void *dest, const void *src) {
-    auto* p64_dest = reinterpret_cast<std::uint64_t*>(dest);  // NOLINT(*-reinterpret-cast)
-    auto* p64_src = reinterpret_cast<const std::uint64_t*>(src);  // NOLINT(*-reinterpret-cast)
+    auto* p64_dest = reinterpret_cast<std::uint64_t*>(dest);  // LINT(*-reinterpret-cast)
+    auto* p64_src = reinterpret_cast<const std::uint64_t*>(src);  // LINT(*-reinterpret-cast)
     *p64_dest = __bswap_64(*p64_src);
 }
 
@@ -92,7 +92,7 @@ static int comp_twisted_key(const std::string_view& a, const std::string_view& b
     return std::memcmp(b.data(), a.data(), write_version_size);
 }
 
-void datastore::create_snapshot() noexcept {  // NOLINT(readability-function-cognitive-complexity)
+void datastore::create_snapshot() noexcept {  // LINT(readability-function-cognitive-complexity)
     auto& from_dir = location_;
 #if defined SORT_METHOD_PUT_ONLY
     auto sortdb = std::make_unique<sortdb_wrapper>(from_dir, comp_twisted_key);
@@ -129,7 +129,7 @@ void datastore::create_snapshot() noexcept {  // NOLINT(readability-function-cog
         // key_sid: storage_id[8] key[*], value_etc: epoch[8]LE minor_version[8]LE value[*], type: type[1]
         // db_key: epoch[8]BE minor_version[8]BE storage_id[8] key[*], db_value: type[1] value[*]
         std::string db_key(write_version_size + e.key_sid().size(), '\0');
-        store_bswap64_value(&db_key[0], &e.value_etc()[0]);  // NOLINT(readability-container-data-pointer)
+        store_bswap64_value(&db_key[0], &e.value_etc()[0]);  // LINT(readability-container-data-pointer)
         store_bswap64_value(&db_key[8], &e.value_etc()[8]);
         std::memcpy(&db_key[write_version_size], e.key_sid().data(), e.key_sid().size());
         std::string db_value(1, static_cast<char>(e.type()));
@@ -214,12 +214,12 @@ void datastore::create_snapshot() noexcept {  // NOLINT(readability-function-cog
 
     boost::filesystem::path snapshot_file = sub_dir / boost::filesystem::path(std::string(snapshot::file_name_));
     VLOG_LP(log_info) << "generating snapshot file: " << snapshot_file;
-    FILE* ostrm = fopen(snapshot_file.c_str(), "w");  // NOLINT(*-owning-memory)
+    FILE* ostrm = fopen(snapshot_file.c_str(), "w");  // LINT(*-owning-memory)
     if (!ostrm) {
         LOG_LP(ERROR) << "cannot create snapshot file (" << snapshot_file << ")";
         std::abort();
     }
-    setvbuf(ostrm, nullptr, _IOFBF, 128L * 1024L);  // NOLINT, NB. glibc may ignore size when _IOFBF and buffer=NULL
+    setvbuf(ostrm, nullptr, _IOFBF, 128L * 1024L);  // LINT, NB. glibc may ignore size when _IOFBF and buffer=NULL
     static_assert(sizeof(log_entry::entry_type) == 1);
 #if defined SORT_METHOD_PUT_ONLY
     sortdb->each([&ostrm, last_key = std::string{}](std::string_view db_key, std::string_view db_value) mutable {
@@ -264,7 +264,7 @@ void datastore::create_snapshot() noexcept {  // NOLINT(readability-function-cog
         }
     });
 #endif
-    if (fclose(ostrm) != 0) {  // NOLINT(*-owning-memory)
+    if (fclose(ostrm) != 0) {  // LINT(*-owning-memory)
         LOG_LP(ERROR) << "cannot close snapshot file (" << snapshot_file << "), errno = " << errno;
         std::abort();
     }

src/limestone/log_channel.cpp

@@ -44,12 +44,12 @@ void log_channel::begin_session() noexcept {
     } while (current_epoch_id_.load() != envelope_.epoch_id_switched_.load());
 
     auto log_file = file_path();
-    strm_ = fopen(log_file.c_str(), "a");  // NOLINT(*-owning-memory)
+    strm_ = fopen(log_file.c_str(), "a");  // LINT(*-owning-memory)
     if (!strm_) {
         LOG_LP(ERROR) << "I/O error, cannot make file on " <<  location_ << ", errno = " << errno;
         std::abort();
     }
-    setvbuf(strm_, nullptr, _IOFBF, 128L * 1024L);  // NOLINT, NB. glibc may ignore size when _IOFBF and buffer=NULL
+    setvbuf(strm_, nullptr, _IOFBF, 128L * 1024L);  // LINT, NB. glibc may ignore size when _IOFBF and buffer=NULL
     if (!registered_) {
         envelope_.add_file(log_file);
         registered_ = true;
@@ -69,7 +69,7 @@ void log_channel::end_session() noexcept {
     finished_epoch_id_.store(current_epoch_id_.load());
     current_epoch_id_.store(UINT64_MAX);
     envelope_.update_min_epoch_id();
-    if (fclose(strm_) != 0) {  // NOLINT(*-owning-memory)
+    if (fclose(strm_) != 0) {  // LINT(*-owning-memory)
         LOG_LP(ERROR) << "fclose failed, errno = " << errno;
         std::abort();
     }

src/limestone/log_entry.h

@@ -252,7 +252,7 @@ class log_entry {
     }
     static std::uint32_t read_uint32le(std::istream& in) {
         std::uint32_t buf{};
-        in.read(reinterpret_cast<char*>(&buf), sizeof(std::uint32_t));  // NOLINT(*-reinterpret-cast)
+        in.read(reinterpret_cast<char*>(&buf), sizeof(std::uint32_t));  // LINT(*-reinterpret-cast)
         return le32toh(buf);
     }
     static void write_uint64le(FILE* out, const std::uint64_t value) {
@@ -261,7 +261,7 @@ class log_entry {
     }
     static std::uint64_t read_uint64le(std::istream& in) {
         std::uint64_t buf{};
-        in.read(reinterpret_cast<char*>(&buf), sizeof(std::uint64_t));  // NOLINT(*-reinterpret-cast)
+        in.read(reinterpret_cast<char*>(&buf), sizeof(std::uint64_t));  // LINT(*-reinterpret-cast)
         return le64toh(buf);
     }
     static void write_bytes(FILE* out, const void* buf, std::size_t len) {

src/limestone/logging_helper.h

@@ -85,8 +85,8 @@ constexpr auto location_prefix(const std::string_view sv) {
 }
 
 template<size_t N, size_t M>
-constexpr auto location_prefix(const char (&prettyname)[N], const char (&funcname)[M]) {  // NOLINT(*-avoid-c-arrays)
-    const std::string_view sv = find_fullname(prettyname, funcname);  // NOLINT(*-bounds-array-to-pointer-decay)
+constexpr auto location_prefix(const char (&prettyname)[N], const char (&funcname)[M]) {  // LINT(*-avoid-c-arrays)
+    const std::string_view sv = find_fullname(prettyname, funcname);  // LINT(*-bounds-array-to-pointer-decay)
     return location_prefix<std::max(N, M)>(sv);
 }
 

src/limestone/sortdb_wrapper.h

@@ -89,13 +89,13 @@ class sortdb_wrapper {
     }
 
     void each(const std::function<void(std::string_view, std::string_view)>& fun) {
-        Iterator* it = sortdb_->NewIterator(ReadOptions());  // NOLINT (typical usage of API)
+        Iterator* it = sortdb_->NewIterator(ReadOptions());  // LINT (typical usage of API)
         for (it->SeekToFirst(); it->Valid(); it->Next()) {
             Slice key = it->key();
             Slice value = it->value();
             fun(std::string_view(key.data(), key.size()), std::string_view(value.data(), value.size()));
         }
-        delete it;  // NOLINT (typical usage of API)
+        delete it;  // LINT (typical usage of API)
     }
 
 private: