Cleanup some clang-tidy issues

Author: greg7mdp

examples/btree.cc

@@ -4,7 +4,11 @@
 
 int main()
 { 
-    // initialise map with some values using an initializer_list
+   phmap::btree_multimap<int, int> foo;
+   for (auto it = foo.begin(); it != foo.end(); it++) {
+   }
+
+   // initialise map with some values using an initializer_list
     phmap::btree_map<std::string, int> map = 
         { { "John", 35 },
           { "Jane", 32 },

examples/matt.cc

@@ -4,6 +4,7 @@
 #include <cstdlib>
 #include <cstdio>
 #include <cmath>
+#include <utility>
 #include <vector>
 #include <random>
 #include <parallel_hashmap/phmap.h>
@@ -14,7 +15,7 @@
 class Timer
 {
 public:
-    Timer(std::string name) : _name(name), _start(std::chrono::high_resolution_clock::now()) {}
+    Timer(std::string name) : _name(std::move(name)), _start(std::chrono::high_resolution_clock::now()) {}
 
     ~Timer() 
     {
@@ -63,7 +64,7 @@ using Perturb = std::function<void (std::vector<uint64_t> &)>;
 // --------------------------------------------------------------------------
 // --------------------------------------------------------------------------
 template<class Set, size_t N>
-void test(const char *name, Perturb perturb1, Perturb /* perturb2 */)
+void test(const char *name, const Perturb &perturb1, const Perturb& /* perturb2 */)
 {
     //phmap::btree_set<uint64_t> s;
     Set s;

examples/mt_word_counter.cc

@@ -48,6 +48,7 @@ int main() {
 
     // run 4 threads, each thread processing lines from one of the vectors
     // -------------------------------------------------------------------
+    threads.reserve(num_threads);
     for (int i = 0; i < num_threads; ++i) {
         threads.emplace_back(
             [&word_counts](std::vector<std::string>&& lines) {

examples/pmr.cc

@@ -16,7 +16,7 @@ struct MyStruct
 {
     template<typename Key, typename Value>
     using ParallelFlatHashMap = phmap::parallel_flat_hash_map<Key, Value, std::hash<Key>, std::equal_to<Key>, 
-                            std::pmr::polymorphic_allocator<std::pair<const Key, Value>>>;
+                                                              std::pmr::polymorphic_allocator<std::pair<const Key, Value>>>;
 
     ParallelFlatHashMap<uint32_t, uint32_t> hashMap;
 

examples/serialize.cc

@@ -55,7 +55,7 @@ class RSU
 
 // --------------------------------------------------------------------------
 // --------------------------------------------------------------------------
-void showtime(const char *name, std::function<void ()> doit)
+void showtime(const char *name, const std::function<void ()>& doit)
 {
     auto t1 = std::chrono::high_resolution_clock::now();
     doit();

parallel_hashmap/btree.h

@@ -737,13 +737,13 @@ namespace priv {
         StringBtreeDefaultLess(std::less<std::string_view>) {}  // NOLINT
         StringBtreeDefaultLess(phmap::Less<std::string_view>) {}  // NOLINT
 
-        phmap::weak_ordering operator()(std::string_view lhs,
-                                        std::string_view rhs) const {
+        phmap::weak_ordering operator()(const std::string_view &lhs,
+                                        const std::string_view &rhs) const {
             return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
         }
 #else
-        phmap::weak_ordering operator()(std::string lhs,
-                                        std::string rhs) const {
+        phmap::weak_ordering operator()(const std::string &lhs,
+                                        const std::string &rhs) const {
             return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
         }
 #endif
@@ -763,8 +763,8 @@ namespace priv {
             return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
         }
 #else
-        phmap::weak_ordering operator()(std::string lhs,
-                                        std::string rhs) const {
+        phmap::weak_ordering operator()(const std::string &lhs,
+                                        const std::string &rhs) const {
             return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
         }
 #endif

parallel_hashmap/phmap.h

@@ -1190,9 +1190,9 @@ class raw_hash_set
         size_(phmap::exchange(that.size_, 0)),
         capacity_(phmap::exchange(that.capacity_, 0)),
         infoz_(phmap::exchange(that.infoz_, HashtablezInfoHandle())),
-    // Hash, equality and allocator are copied instead of moved because
-    // `that` must be left valid. If Hash is std::function<Key>, moving it
-    // would create a nullptr functor that cannot be called.
+        // Hash, equality and allocator are copied instead of moved because
+        // `that` must be left valid. If Hash is std::function<Key>, moving it
+        // would create a nullptr functor that cannot be called.
         settings_(that.settings_) {
         // growth_left was copied above, reset the one from `that`.
         that.growth_left() = 0;

parallel_hashmap/phmap_base.h

@@ -2047,7 +2047,7 @@ class optional : private optional_internal::optional_data<T>,
     optional(const optional& src) = default;
 
     // Move constructor, standard semantics
-    optional(optional&& src) = default;
+    optional(optional&& src) noexcept = default;
 
     // Constructs a non-empty `optional` direct-initialized value of type `T` from
     // the arguments `std::forward<Args>(args)...`  within the `optional`.
@@ -2187,7 +2187,7 @@ class optional : private optional_internal::optional_data<T>,
     optional& operator=(const optional& src) = default;
 
     // Move assignment operator, standard semantics
-    optional& operator=(optional&& src) = default;
+    optional& operator=(optional&& src) noexcept = default;
 
     // Value assignment operators
     template <
@@ -4765,7 +4765,7 @@ class LockableBaseImpl
         DoNothing(mutex_type&, phmap::try_to_lock_t) {}
         template<class T> explicit DoNothing(T&&) {}
         DoNothing& operator=(const DoNothing&) { return *this; }
-        DoNothing& operator=(DoNothing&&) { return *this; }
+        DoNothing& operator=(DoNothing&&) noexcept { return *this; }
         void swap(DoNothing &) {}
         bool owns_lock() const noexcept { return true; }
     };
@@ -4796,13 +4796,13 @@ class LockableBaseImpl
             m_->try_lock(); 
         }
 
-        WriteLock(WriteLock &&o) :
+        WriteLock(WriteLock &&o) noexcept :
             m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
             o.locked_ = false;
             o.m_      = nullptr;
         }
 
-        WriteLock& operator=(WriteLock&& other) {
+        WriteLock& operator=(WriteLock&& other) noexcept {
             WriteLock temp(std::move(other));
             swap(temp);
             return *this;
@@ -4874,13 +4874,13 @@ class LockableBaseImpl
             m_->try_lock_shared(); 
         }
 
-        ReadLock(ReadLock &&o) :
+        ReadLock(ReadLock &&o) noexcept :
             m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
             o.locked_ = false;
             o.m_      = nullptr;
         }
 
-        ReadLock& operator=(ReadLock&& other) {
+        ReadLock& operator=(ReadLock&& other) noexcept {
             ReadLock temp(std::move(other));
             swap(temp);
             return *this;