@nxtedition/rocksdb 7.1.30 → 7.1.32

package/deps/rocksdb/rocksdb/util/crc32c.h

@@ -10,6 +10,7 @@
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
+
 #include <string>
 
 #include "rocksdb/rocksdb_namespace.h"
@@ -31,9 +32,7 @@ extern uint32_t Extend(uint32_t init_crc, const char* data, size_t n);
 extern uint32_t Crc32cCombine(uint32_t crc1, uint32_t crc2, size_t crc2len);
 
 // Return the crc32c of data[0,n-1]
-inline uint32_t Value(const char* data, size_t n) {
-  return Extend(0, data, n);
-}
+inline uint32_t Value(const char* data, size_t n) { return Extend(0, data, n); }
 
 static const uint32_t kMaskDelta = 0xa282ead8ul;
 

package/deps/rocksdb/rocksdb/util/crc32c_arm64.h

@@ -18,6 +18,7 @@
 #define crc32c_u16(crc, v) __crc32ch(crc, v)
 #define crc32c_u32(crc, v) __crc32cw(crc, v)
 #define crc32c_u64(crc, v) __crc32cd(crc, v)
+// clang-format off
 #define PREF4X64L1(buffer, PREF_OFFSET, ITR)                \
   __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
           [c] "I"((PREF_OFFSET) + ((ITR) + 0) * 64));       \
@@ -27,6 +28,7 @@
           [c] "I"((PREF_OFFSET) + ((ITR) + 2) * 64));       \
   __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \
           [c] "I"((PREF_OFFSET) + ((ITR) + 3) * 64));
+// clang-format on
 
 #define PREF1KL1(buffer, PREF_OFFSET)  \
   PREF4X64L1(buffer, (PREF_OFFSET), 0) \

package/deps/rocksdb/rocksdb/util/crc32c_test.cc

@@ -15,8 +15,7 @@
 namespace ROCKSDB_NAMESPACE {
 namespace crc32c {
 
-class CRC { };
-
+class CRC {};
 
 // Tests for 3-way crc32c algorithm. We need these tests because it uses
 // different lookup tables than the original Fast_CRC32
@@ -31,42 +30,41 @@ struct ExpectedResult {
 
 ExpectedResult expectedResults[] = {
     // Zero-byte input
-    { 0, 0, ~0U },
+    {0, 0, ~0U},
     // Small aligned inputs to test special cases in SIMD implementations
-    { 8, 1, 1543413366 },
-    { 8, 2, 523493126 },
-    { 8, 3, 1560427360 },
-    { 8, 4, 3422504776 },
-    { 8, 5, 447841138 },
-    { 8, 6, 3910050499 },
-    { 8, 7, 3346241981 },
+    {8, 1, 1543413366},
+    {8, 2, 523493126},
+    {8, 3, 1560427360},
+    {8, 4, 3422504776},
+    {8, 5, 447841138},
+    {8, 6, 3910050499},
+    {8, 7, 3346241981},
     // Small unaligned inputs
-    { 9, 1, 3855826643 },
-    { 10, 2, 560880875 },
-    { 11, 3, 1479707779 },
-    { 12, 4, 2237687071 },
-    { 13, 5, 4063855784 },
-    { 14, 6, 2553454047 },
-    { 15, 7, 1349220140 },
+    {9, 1, 3855826643},
+    {10, 2, 560880875},
+    {11, 3, 1479707779},
+    {12, 4, 2237687071},
+    {13, 5, 4063855784},
+    {14, 6, 2553454047},
+    {15, 7, 1349220140},
     // Larger inputs to test leftover chunks at the end of aligned blocks
-    { 8, 8, 627613930 },
-    { 8, 9, 2105929409 },
-    { 8, 10, 2447068514 },
-    { 8, 11, 863807079 },
-    { 8, 12, 292050879 },
-    { 8, 13, 1411837737 },
-    { 8, 14, 2614515001 },
-    { 8, 15, 3579076296 },
-    { 8, 16, 2897079161 },
-    { 8, 17, 675168386 },
+    {8, 8, 627613930},
+    {8, 9, 2105929409},
+    {8, 10, 2447068514},
+    {8, 11, 863807079},
+    {8, 12, 292050879},
+    {8, 13, 1411837737},
+    {8, 14, 2614515001},
+    {8, 15, 3579076296},
+    {8, 16, 2897079161},
+    {8, 17, 675168386},
     // // Much larger inputs
-    { 0, BUFFER_SIZE, 2096790750 },
-    { 1, BUFFER_SIZE / 2, 3854797577 },
+    {0, BUFFER_SIZE, 2096790750},
+    {1, BUFFER_SIZE / 2, 3854797577},
 
 };
 
 TEST(CRC, StandardResults) {
-
   // Original Fast_CRC32 tests.
   // From rfc3720 section B.4.
   char buf[32];
@@ -88,18 +86,10 @@ TEST(CRC, StandardResults) {
   ASSERT_EQ(0x113fdb5cU, Value(buf, sizeof(buf)));
 
   unsigned char data[48] = {
-    0x01, 0xc0, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x04, 0x00,
-    0x00, 0x00, 0x00, 0x14,
-    0x00, 0x00, 0x00, 0x18,
-    0x28, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
+      0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
+      0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
   ASSERT_EQ(0xd9963a56, Value(reinterpret_cast<char*>(data), sizeof(data)));
 
@@ -114,21 +104,17 @@ TEST(CRC, StandardResults) {
   for (auto expected : expectedResults) {
     size_t partialLength = expected.length / 2;
     uint32_t partialChecksum = Value(buffer + expected.offset, partialLength);
-    uint32_t result = Extend(partialChecksum,
-        buffer + expected.offset + partialLength,
-        expected.length - partialLength);
+    uint32_t result =
+        Extend(partialChecksum, buffer + expected.offset + partialLength,
+               expected.length - partialLength);
     EXPECT_EQ(~expected.crc32c, result);
   }
-
 }
 
-TEST(CRC, Values) {
-  ASSERT_NE(Value("a", 1), Value("foo", 3));
-}
+TEST(CRC, Values) { ASSERT_NE(Value("a", 1), Value("foo", 3)); }
 
 TEST(CRC, Extend) {
-  ASSERT_EQ(Value("hello world", 11),
-            Extend(Value("hello ", 6), "world", 5));
+  ASSERT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5));
 }
 
 TEST(CRC, Mask) {
@@ -189,15 +175,14 @@ TEST(CRC, Crc32cCombineBigSizeTest) {
 
 // copied from folly
 const uint64_t FNV_64_HASH_START = 14695981039346656037ULL;
-inline uint64_t fnv64_buf(const void* buf,
-                          size_t n,
+inline uint64_t fnv64_buf(const void* buf, size_t n,
                           uint64_t hash = FNV_64_HASH_START) {
   // forcing signed char, since other platforms can use unsigned
   const signed char* char_buf = reinterpret_cast<const signed char*>(buf);
 
   for (size_t i = 0; i < n; ++i) {
     hash += (hash << 1) + (hash << 4) + (hash << 5) + (hash << 7) +
-      (hash << 8) + (hash << 40);
+            (hash << 8) + (hash << 40);
     hash ^= char_buf[i];
   }
   return hash;

package/deps/rocksdb/rocksdb/util/defer.h

@@ -37,7 +37,8 @@ namespace ROCKSDB_NAMESPACE {
 //    but sometimes, this might lead to nested blocks of "if (s.ok()) {...}".
 //
 // With the help of Defer, you can centralize the cleanup logic inside the
-// lambda passed to Defer, and you can return immediately on failure when necessary.
+// lambda passed to Defer, and you can return immediately on failure when
+// necessary.
 class Defer final {
  public:
   explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}

package/deps/rocksdb/rocksdb/util/defer_test.cc

@@ -3,10 +3,11 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+#include "util/defer.h"
+
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "test_util/testharness.h"
-#include "util/defer.h"
 
 namespace ROCKSDB_NAMESPACE {
 

package/deps/rocksdb/rocksdb/util/duplicate_detector.h

@@ -54,7 +54,8 @@ class DuplicateDetector {
           db_->immutable_db_options().info_log,
           "Recovering an entry from the dropped column family %" PRIu32
           ". WAL must must have been emptied before dropping the column "
-          "family", cf);
+          "family",
+          cf);
 #ifndef ROCKSDB_LITE
       throw std::runtime_error(
           "Recovering an entry from a dropped column family. "

package/deps/rocksdb/rocksdb/util/dynamic_bloom.cc

@@ -23,7 +23,7 @@ uint32_t roundUpToPow2(uint32_t x) {
   }
   return rv;
 }
-}
+}  // namespace
 
 DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,
                            uint32_t num_probes, size_t huge_page_tlb_size,

package/deps/rocksdb/rocksdb/util/dynamic_bloom.h

@@ -6,15 +6,15 @@
 #pragma once
 
 #include <array>
+#include <atomic>
+#include <memory>
 #include <string>
+
 #include "port/port.h"
 #include "rocksdb/slice.h"
 #include "table/multiget_context.h"
 #include "util/hash.h"
 
-#include <atomic>
-#include <memory>
-
 namespace ROCKSDB_NAMESPACE {
 
 class Slice;

package/deps/rocksdb/rocksdb/util/dynamic_bloom_test.cc

@@ -314,7 +314,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   ParseCommandLineFlags(&argc, &argv, true);

package/deps/rocksdb/rocksdb/util/filelock_test.cc

@@ -3,15 +3,16 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 //
-#include "rocksdb/status.h"
-#include "rocksdb/env.h"
-
 #include <fcntl.h>
+
+#include "rocksdb/env.h"
+#include "rocksdb/status.h"
 #ifdef __FreeBSD__
 #include <sys/types.h>
 #include <sys/wait.h>
 #endif
 #include <vector>
+
 #include "test_util/testharness.h"
 #include "util/coding.h"
 #include "util/string_util.h"
@@ -32,23 +33,19 @@ class LockTest : public testing::Test {
 
   ~LockTest() override {}
 
-  Status LockFile(FileLock** db_lock) {
-    return env_->LockFile(file_, db_lock);
-  }
+  Status LockFile(FileLock** db_lock) { return env_->LockFile(file_, db_lock); }
 
-  Status UnlockFile(FileLock* db_lock) {
-    return env_->UnlockFile(db_lock);
-  }
+  Status UnlockFile(FileLock* db_lock) { return env_->UnlockFile(db_lock); }
 
-  bool AssertFileIsLocked(){
-    return CheckFileLock( /* lock_expected = */ true);
+  bool AssertFileIsLocked() {
+    return CheckFileLock(/* lock_expected = */ true);
   }
 
-  bool AssertFileIsNotLocked(){
-    return CheckFileLock( /* lock_expected = */ false);
+  bool AssertFileIsNotLocked() {
+    return CheckFileLock(/* lock_expected = */ false);
   }
 
-  bool CheckFileLock(bool lock_expected){
+  bool CheckFileLock(bool lock_expected) {
     // We need to fork to check the fcntl lock as we need
     // to open and close the file from a different process
     // to avoid either releasing the lock on close, or not
@@ -63,13 +60,13 @@ class LockTest : public testing::Test {
 #else
 
     pid_t pid = fork();
-    if ( 0 == pid ) {
+    if (0 == pid) {
       // child process
       int exit_val = EXIT_FAILURE;
       int fd = open(file_.c_str(), O_RDWR | O_CREAT, 0644);
       if (fd < 0) {
         // could not open file, could not check if it was locked
-        fprintf( stderr, "Open on on file %s failed.\n",file_.c_str());
+        fprintf(stderr, "Open on on file %s failed.\n", file_.c_str());
         exit(exit_val);
       }
 
@@ -78,23 +75,24 @@ class LockTest : public testing::Test {
       f.l_type = (F_WRLCK);
       f.l_whence = SEEK_SET;
       f.l_start = 0;
-      f.l_len = 0; // Lock/unlock entire file
+      f.l_len = 0;  // Lock/unlock entire file
       int value = fcntl(fd, F_SETLK, &f);
-      if( value == -1 ){
-        if( lock_expected ){
+      if (value == -1) {
+        if (lock_expected) {
           exit_val = EXIT_SUCCESS;
         }
       } else {
-        if( ! lock_expected ){
+        if (!lock_expected) {
           exit_val = EXIT_SUCCESS;
         }
       }
-      close(fd); // lock is released for child process
+      close(fd);  // lock is released for child process
       exit(exit_val);
     } else if (pid > 0) {
       // parent process
       int status;
-      while (-1 == waitpid(pid, &status, 0));
+      while (-1 == waitpid(pid, &status, 0))
+        ;
       if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
         // child process exited with non success status
         return false;
@@ -102,15 +100,13 @@ class LockTest : public testing::Test {
         return true;
       }
     } else {
-      fprintf( stderr, "Fork failed\n" );
+      fprintf(stderr, "Fork failed\n");
       return false;
     }
     return false;
 
 #endif
-
   }
-
 };
 LockTest* LockTest::current_;
 
@@ -122,7 +118,7 @@ TEST_F(LockTest, LockBySameThread) {
   ASSERT_OK(LockFile(&lock1));
 
   // check the file is locked
-  ASSERT_TRUE( AssertFileIsLocked() );
+  ASSERT_TRUE(AssertFileIsLocked());
 
   // re-acquire the lock on the same file. This should fail.
   Status s = LockFile(&lock2);
@@ -134,14 +130,13 @@ TEST_F(LockTest, LockBySameThread) {
 #endif
 
   // check the file is locked
-  ASSERT_TRUE( AssertFileIsLocked() );
+  ASSERT_TRUE(AssertFileIsLocked());
 
   // release the lock
   ASSERT_OK(UnlockFile(lock1));
 
   // check the file is not locked
-  ASSERT_TRUE( AssertFileIsNotLocked() );
-
+  ASSERT_TRUE(AssertFileIsNotLocked());
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/filter_bench.cc

@@ -195,7 +195,7 @@ struct KeyMaker {
       len += FastRange32(
           (val_num >> FLAGS_vary_key_size_log2_interval) * 1234567891, 5);
     }
-    char * data = buf_.get() + start;
+    char *data = buf_.get() + start;
     // Populate key data such that all data makes it into a key of at
     // least 8 bytes. We also don't want all the within-filter key
     // variance confined to a contiguous 32 bits, because then a 32 bit
@@ -378,9 +378,9 @@ void FilterBench::Go() {
                                     FLAGS_average_keys_per_filter);
   const uint32_t variance_offset = variance_range / 2;
 
-  const std::vector<TestMode> &testModes =
-      FLAGS_best_case ? bestCaseTestModes
-                      : FLAGS_quick ? quickTestModes : allTestModes;
+  const std::vector<TestMode> &testModes = FLAGS_best_case ? bestCaseTestModes
+                                           : FLAGS_quick   ? quickTestModes
+                                                           : allTestModes;
 
   m_queries_ = FLAGS_m_queries;
   double working_mem_size_mb = FLAGS_working_mem_size_mb;

package/deps/rocksdb/rocksdb/util/hash_test.cc

@@ -547,7 +547,7 @@ TEST(FastRangeGenericTest, Values) {
             uint16_t{6234});
   // Not recommended for typical use because for example this could fail on
   // some platforms and pass on others:
-  //EXPECT_EQ(FastRangeGeneric(static_cast<unsigned long>(0x80000000),
+  // EXPECT_EQ(FastRangeGeneric(static_cast<unsigned long>(0x80000000),
   //                           uint16_t{12468}),
   //          uint16_t{6234});
 }
@@ -843,7 +843,7 @@ TEST(MathTest, CodingGeneric) {
   EXPECT_EQ(std::string("_12"), std::string(out));
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   fprintf(stderr, "NPHash64 id: %x\n",
           static_cast<int>(ROCKSDB_NAMESPACE::GetSliceNPHash64("RocksDB")));
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();

package/deps/rocksdb/rocksdb/util/heap.h

@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <functional>
+
 #include "port/port.h"
 #include "util/autovector.h"
 
@@ -37,11 +38,11 @@ namespace ROCKSDB_NAMESPACE {
 // std::priority_queue: the comparison operator is expected to provide the
 // less-than relation, but top() will return the maximum.
 
-template<typename T, typename Compare = std::less<T>>
+template <typename T, typename Compare = std::less<T>>
 class BinaryHeap {
  public:
-  BinaryHeap() { }
-  explicit BinaryHeap(Compare cmp) : cmp_(std::move(cmp)) { }
+  BinaryHeap() {}
+  explicit BinaryHeap(Compare cmp) : cmp_(std::move(cmp)) {}
 
   void push(const T& value) {
     data_.push_back(value);
@@ -86,7 +87,7 @@ class BinaryHeap {
     }
   }
 
-  void swap(BinaryHeap &other) {
+  void swap(BinaryHeap& other) {
     std::swap(cmp_, other.cmp_);
     data_.swap(other.data_);
     std::swap(root_cmp_cache_, other.root_cmp_cache_);

package/deps/rocksdb/rocksdb/util/heap_test.cc

@@ -31,8 +31,7 @@ namespace ROCKSDB_NAMESPACE {
 using HeapTestValue = uint64_t;
 using Params = std::tuple<size_t, HeapTestValue, int64_t>;
 
-class HeapTest : public ::testing::TestWithParam<Params> {
-};
+class HeapTest : public ::testing::TestWithParam<Params> {};
 
 TEST_P(HeapTest, Test) {
   // This test performs the same pseudorandom sequence of operations on a
@@ -54,15 +53,14 @@ TEST_P(HeapTest, Test) {
   std::mt19937 rng(static_cast<unsigned int>(RNG_SEED));
   std::uniform_int_distribution<HeapTestValue> value_dist(0, MAX_VALUE);
   int ndrains = 0;
-  bool draining = false;     // hit max size, draining until we empty the heap
+  bool draining = false;  // hit max size, draining until we empty the heap
   size_t size = 0;
   for (int64_t i = 0; i < FLAGS_iters; ++i) {
     if (size == 0) {
       draining = false;
     }
 
-    if (!draining &&
-        (size == 0 || std::bernoulli_distribution(0.4)(rng))) {
+    if (!draining && (size == 0 || std::bernoulli_distribution(0.4)(rng))) {
       // insert
       HeapTestValue val = value_dist(rng);
       heap.push(val);
@@ -104,30 +102,22 @@ TEST_P(HeapTest, Test) {
 }
 
 // Basic test, MAX_VALUE = 3*MAX_HEAP_SIZE (occasional duplicates)
-INSTANTIATE_TEST_CASE_P(
-  Basic, HeapTest,
-  ::testing::Values(Params(1000, 3000, 0x1b575cf05b708945))
-);
+INSTANTIATE_TEST_CASE_P(Basic, HeapTest,
+                        ::testing::Values(Params(1000, 3000,
+                                                 0x1b575cf05b708945)));
 // Mid-size heap with small values (many duplicates)
-INSTANTIATE_TEST_CASE_P(
-  SmallValues, HeapTest,
-  ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0))
-);
+INSTANTIATE_TEST_CASE_P(SmallValues, HeapTest,
+                        ::testing::Values(Params(100, 10, 0x5ae213f7bd5dccd0)));
 // Small heap, large value range (no duplicates)
-INSTANTIATE_TEST_CASE_P(
-  SmallHeap, HeapTest,
-  ::testing::Values(Params(10, ULLONG_MAX, 0x3e1fa8f4d01707cf))
-);
+INSTANTIATE_TEST_CASE_P(SmallHeap, HeapTest,
+                        ::testing::Values(Params(10, ULLONG_MAX,
+                                                 0x3e1fa8f4d01707cf)));
 // Two-element heap
-INSTANTIATE_TEST_CASE_P(
-  TwoElementHeap, HeapTest,
-  ::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc))
-);
+INSTANTIATE_TEST_CASE_P(TwoElementHeap, HeapTest,
+                        ::testing::Values(Params(2, 5, 0x4b5e13ea988c6abc)));
 // One-element heap
-INSTANTIATE_TEST_CASE_P(
-  OneElementHeap, HeapTest,
-  ::testing::Values(Params(1, 3, 0x176a1019ab0b612e))
-);
+INSTANTIATE_TEST_CASE_P(OneElementHeap, HeapTest,
+                        ::testing::Values(Params(1, 3, 0x176a1019ab0b612e)));
 
 }  // namespace ROCKSDB_NAMESPACE
 

package/deps/rocksdb/rocksdb/util/kv_map.h

@@ -29,5 +29,5 @@ struct LessOfComparator {
 };
 
 using KVMap = std::map<std::string, std::string, LessOfComparator>;
-}
+}  // namespace stl_wrappers
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/murmurhash.cc

@@ -10,6 +10,7 @@
   is under the MIT license.
 */
 #include "murmurhash.h"
+
 #include "port/lang.h"
 
 #if defined(__x86_64__)
@@ -28,6 +29,7 @@ __attribute__((__no_sanitize__("alignment")))
 __attribute__((__no_sanitize_undefined__))
 #endif
 #endif
+// clang-format off
 uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed )
 {
     const uint64_t m = 0xc6a4a7935bd1e995;
@@ -70,6 +72,7 @@ uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed )
 
     return h;
 }
+// clang-format on
 
 #elif defined(__i386__)
 
@@ -85,7 +88,7 @@ uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed )
 // 1. It will not work incrementally.
 // 2. It will not produce the same results on little-endian and big-endian
 //    machines.
-
+// clang-format off
 unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed )
 {
     // 'm' and 'r' are mixing constants generated offline.
@@ -136,6 +139,7 @@ unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed )
 
     return h;
 }
+// clang-format on
 
 #else
 
@@ -143,7 +147,7 @@ unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed )
 //
 // Same as MurmurHash2, but endian- and alignment-neutral.
 // Half the speed though, alas.
-
+// clang-format off
 unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed )
 {
     const unsigned int m = 0x5bd1e995;
@@ -187,5 +191,6 @@ unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed )
 
     return h;
 }
+// clang-format on
 
 #endif

package/deps/rocksdb/rocksdb/util/murmurhash.h

@@ -11,23 +11,24 @@
 */
 #pragma once
 #include <stdint.h>
+
 #include "rocksdb/slice.h"
 
 #if defined(__x86_64__)
 #define MURMUR_HASH MurmurHash64A
-uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed );
+uint64_t MurmurHash64A(const void* key, int len, unsigned int seed);
 #define MurmurHash MurmurHash64A
 using murmur_t = uint64_t;
 
 #elif defined(__i386__)
 #define MURMUR_HASH MurmurHash2
-unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed );
+unsigned int MurmurHash2(const void* key, int len, unsigned int seed);
 #define MurmurHash MurmurHash2
 using murmur_t = unsigned int;
 
 #else
 #define MURMUR_HASH MurmurHashNeutral2
-unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed );
+unsigned int MurmurHashNeutral2(const void* key, int len, unsigned int seed);
 #define MurmurHash MurmurHashNeutral2
 using murmur_t = unsigned int;
 #endif