Use std::forward recommended by clion.

2 files changed, 16 insertions, 14 deletions

diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_search.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_search.cpp
index 9e887b9d0f7..89be49f8771 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/parallel_weak_and_search.cpp
@@ -199,17 +199,17 @@ namespace {
 template <typename VectorizedTerms, typename FutureHeap, typename PastHeap>
 SearchIterator::UP create_helper(search::fef::TermFieldMatchData &tfmd, VectorizedTerms &&terms, const MatchParams &params, bool strict) {
     if (strict) {
-        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, true>>(tfmd, std::move(terms), params);
+        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, true>>(tfmd, std::forward<VectorizedTerms>(terms), params);
     } else {
-        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, false>>(tfmd, std::move(terms), params);
+        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, false>>(tfmd, std::forward<VectorizedTerms>(terms), params);
     }
 }
 
 template <typename VectorizedTerms>
 SearchIterator::UP create_helper(search::fef::TermFieldMatchData &tfmd, VectorizedTerms &&terms, const MatchParams &params, bool strict, bool use_array) {
     return (use_array)
-        ? create_helper<VectorizedTerms, vespalib::LeftArrayHeap, vespalib::RightArrayHeap>(tfmd, std::move(terms), params, strict)
-        : create_helper<VectorizedTerms, vespalib::LeftHeap, vespalib::RightHeap>(tfmd, std::move(terms), params, strict);
+        ? create_helper<VectorizedTerms, vespalib::LeftArrayHeap, vespalib::RightArrayHeap>(tfmd, std::forward<VectorizedTerms>(terms), params, strict)
+        : create_helper<VectorizedTerms, vespalib::LeftHeap, vespalib::RightHeap>(tfmd, std::forward<VectorizedTerms>(terms), params, strict);
 }
 
 } // namespace search::queryeval::<unnamed>
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.h b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.h
index f1c90f5e6ac..4ac502967ac 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_heap.h
@@ -17,13 +17,13 @@ namespace search::queryeval {
 class WeakAndHeap {
 public:
     using score_t = wand::score_t;
-    WeakAndHeap(uint32_t scoresToTrack) :
+    explicit WeakAndHeap(uint32_t scoresToTrack) noexcept :
        _minScore((scoresToTrack == 0)
                     ? std::numeric_limits<score_t>::max()
                     : 0),
        _scoresToTrack(scoresToTrack)
     { }
-    virtual ~WeakAndHeap() {}
+    virtual ~WeakAndHeap() = default;
     /**
      * Consider the given scores for insertion into the underlying structure.
      * The implementation may change the given score array to speed up execution.
@@ -33,11 +33,13 @@ public:
     /**
      * The number of scores this heap is tracking.
      **/
-    uint32_t getScoresToTrack() const { return _scoresToTrack; }
+    uint32_t getScoresToTrack() const noexcept { return _scoresToTrack; }
 
-    score_t getMinScore() const { return _minScore.load(std::memory_order_relaxed); }
+    score_t getMinScore() const noexcept { return _minScore.load(std::memory_order_relaxed); }
 protected:
-    void setMinScore(score_t minScore) { _minScore.store(minScore, std::memory_order_relaxed); }
+    void setMinScore(score_t minScore) noexcept {
+        _minScore.store(minScore, std::memory_order_relaxed);
+    }
 private:
     std::atomic<score_t> _minScore;
     const uint32_t _scoresToTrack;
@@ -47,19 +49,19 @@ private:
  * An implementation using an underlying priority queue to keep track of the N
  * best hits that can be shared among multiple search iterators.
  */
-class SharedWeakAndPriorityQueue : public WeakAndHeap
+class SharedWeakAndPriorityQueue final : public WeakAndHeap
 {
 private:
     using Scores = vespalib::PriorityQueue<score_t>;
     Scores         _bestScores;
     std::mutex     _lock;
 
-    bool is_full() const { return (_bestScores.size() >= getScoresToTrack()); }
+    bool is_full() const noexcept { return (_bestScores.size() >= getScoresToTrack()); }
 
 public:
-    SharedWeakAndPriorityQueue(uint32_t scoresToTrack);
-    ~SharedWeakAndPriorityQueue();
-    Scores &getScores() { return _bestScores; }
+    explicit SharedWeakAndPriorityQueue(uint32_t scoresToTrack);
+    ~SharedWeakAndPriorityQueue() override;
+    Scores &getScores() noexcept { return _bestScores; }
     void adjust(score_t *begin, score_t *end) override;
 };