Merge pull request #30906 from vespa-engine/balder/add-noexcept-1

- Add noexcept, const and final where it makes sense.

3 files changed, 31 insertions, 34 deletions

diff --git a/searchlib/src/vespa/searchlib/queryeval/hitcollector.cpp b/searchlib/src/vespa/searchlib/queryeval/hitcollector.cpp
index b43b560ae2a..bf7f44f0e7a 100644
--- a/searchlib/src/vespa/searchlib/queryeval/hitcollector.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/hitcollector.cpp
@@ -34,8 +34,7 @@ HitCollector::sortHitsByDocId()
     }
 }
 
-HitCollector::HitCollector(uint32_t numDocs,
-                           uint32_t maxHitsSize)
+HitCollector::HitCollector(uint32_t numDocs, uint32_t maxHitsSize)
     : _numDocs(numDocs),
       _maxHitsSize(std::min(maxHitsSize, numDocs)),
       _maxDocIdVectorSize((numDocs + 31) / 32),
@@ -63,14 +62,14 @@ HitCollector::RankedHitCollector::collect(uint32_t docId, feature_t score)
 {
     HitCollector & hc = this->_hc;
     if (hc._hits.size() < hc._maxHitsSize) {
-        if (__builtin_expect(((hc._hits.size() > 0) &&
+        if (__builtin_expect(((!hc._hits.empty()) &&
                               (docId < hc._hits.back().first) &&
                               (hc._hitsSortOrder == SortOrder::DOC_ID)), false))
         {
             hc._hitsSortOrder = SortOrder::NONE;
             hc._unordered = true;
         }
-        hc._hits.push_back(std::make_pair(docId, score));
+        hc._hits.emplace_back(docId, score);
     } else {
         collectAndChangeCollector(docId, score);
     }
@@ -86,7 +85,7 @@ HitCollector::BitVectorCollector<CollectRankedHit>::collect(uint32_t docId, feat
 }
 
 void
-HitCollector::CollectorBase::replaceHitInVector(uint32_t docId, feature_t score) {
+HitCollector::CollectorBase::replaceHitInVector(uint32_t docId, feature_t score) noexcept {
     // replace lowest scored hit in hit vector
     std::pop_heap(_hc._hits.begin(), _hc._hits.end(), ScoreComparator());
     _hc._hits.back().first = docId;
@@ -138,7 +137,7 @@ HitCollector::DocIdCollector<CollectRankedHit>::collect(uint32_t docId, feature_
     }
     HitCollector & hc = this->_hc;
     if (hc._docIdVector.size() < hc._maxDocIdVectorSize) {
-        if (__builtin_expect(((hc._docIdVector.size() > 0) &&
+        if (__builtin_expect(((!hc._docIdVector.empty()) &&
                               (docId < hc._docIdVector.back()) &&
                               (hc._unordered == false)), false))
         {
@@ -173,7 +172,7 @@ HitCollector::getSortedHitSequence(size_t max_hits)
 {
     size_t num_hits = std::min(_hits.size(), max_hits);
     sortHitsByScore(num_hits);
-    return SortedHitSequence(_hits.data(), _scoreOrder.data(), num_hits);
+    return {_hits.data(), _scoreOrder.data(), num_hits};
 }
 
 void
diff --git a/searchlib/src/vespa/searchlib/queryeval/hitcollector.h b/searchlib/src/vespa/searchlib/queryeval/hitcollector.h
index a98a5bdf625..94ffe619bab 100644
--- a/searchlib/src/vespa/searchlib/queryeval/hitcollector.h
+++ b/searchlib/src/vespa/searchlib/queryeval/hitcollector.h
@@ -39,7 +39,7 @@ private:
     feature_t _adjust;
 
     struct ScoreComparator {
-        bool operator() (const Hit & lhs, const Hit & rhs) const {
+        bool operator() (const Hit & lhs, const Hit & rhs) const noexcept {
             if (lhs.second == rhs.second) {
                 return (lhs.first < rhs.first);
             }
@@ -48,7 +48,7 @@ private:
     };
 
     struct IndirectScoreComparator {
-        IndirectScoreComparator(const Hit * hits) : _hits(hits) { }
+        explicit IndirectScoreComparator(const Hit * hits) noexcept : _hits(hits) { }
         bool operator() (uint32_t lhs, uint32_t rhs) const {
             if (_hits[lhs].second == _hits[rhs].second) {
                 return (_hits[lhs].first < _hits[rhs].first);
@@ -59,17 +59,17 @@ private:
     };
 
     struct IndirectScoreRadix {
-        IndirectScoreRadix(const Hit * hits) : _hits(hits) { }
-        uint64_t operator () (uint32_t v) {
+        explicit IndirectScoreRadix(const Hit * hits) noexcept : _hits(hits) { }
+        uint64_t operator () (uint32_t v) const noexcept {
             return vespalib::convertForSort<double, false>::convert(_hits[v].second);
         }
         const Hit * _hits;
     };
     struct DocIdRadix {
-        uint32_t operator () (const Hit & v) { return v.first; }
+        uint32_t operator () (const Hit & v) const noexcept { return v.first; }
     };
     struct DocIdComparator {
-        bool operator() (const Hit & lhs, const Hit & rhs) const {
+        bool operator() (const Hit & lhs, const Hit & rhs) const noexcept {
             return (lhs.first < rhs.first);
         }
     };
@@ -77,47 +77,47 @@ private:
     class Collector {
     public:
         using UP = std::unique_ptr<Collector>;
-        virtual ~Collector() {}
+        virtual ~Collector() = default;
         virtual void collect(uint32_t docId, feature_t score) = 0;
-        virtual bool isDocIdCollector() const { return false; }
+        virtual bool isDocIdCollector() const noexcept { return false; }
     };
 
     Collector::UP _collector;
 
     class CollectorBase : public Collector {
     public:
-        CollectorBase(HitCollector &hc) : _hc(hc) { }
+        explicit CollectorBase(HitCollector &hc) noexcept : _hc(hc) { }
         void considerForHitVector(uint32_t docId, feature_t score) {
             if (__builtin_expect((score > _hc._hits[0].second), false)) {
                 replaceHitInVector(docId, score);
             }
         }
     protected:
-        void replaceHitInVector(uint32_t docId, feature_t score);
+        VESPA_DLL_LOCAL void replaceHitInVector(uint32_t docId, feature_t score) noexcept;
         HitCollector &_hc;
     };
 
-    class RankedHitCollector : public CollectorBase {
+    class RankedHitCollector final : public CollectorBase {
     public:
-        RankedHitCollector(HitCollector &hc) : CollectorBase(hc) { }
+        explicit RankedHitCollector(HitCollector &hc) noexcept : CollectorBase(hc) { }
         void collect(uint32_t docId, feature_t score) override;
         void collectAndChangeCollector(uint32_t docId, feature_t score) __attribute__((noinline));
     };
 
     template <bool CollectRankedHit>
-    class DocIdCollector : public CollectorBase {
+    class DocIdCollector final : public CollectorBase {
     public:
-        DocIdCollector(HitCollector &hc) : CollectorBase(hc) { }
+        explicit DocIdCollector(HitCollector &hc) noexcept : CollectorBase(hc) { }
         void collect(uint32_t docId, feature_t score) override;
         void collectAndChangeCollector(uint32_t docId) __attribute__((noinline));
-        bool isDocIdCollector() const override { return true; }
+        bool isDocIdCollector() const noexcept override { return true; }
     };
 
     template <bool CollectRankedHit>
-    class BitVectorCollector : public CollectorBase {
+    class BitVectorCollector final : public CollectorBase {
     public:
-        BitVectorCollector(HitCollector &hc) : CollectorBase(hc) { }
-        virtual void collect(uint32_t docId, feature_t score) override;
+        explicit BitVectorCollector(HitCollector &hc) noexcept : CollectorBase(hc) { }
+        void collect(uint32_t docId, feature_t score) override;
     };
 
     HitRank getReScore(feature_t score) const {
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
index f5231cf3509..f915a7df335 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
@@ -7,12 +7,11 @@
 #include <vespa/vespalib/util/priority_queue.h>
 #include <vespa/vespalib/objects/visit.hpp>
 
-namespace search {
-namespace queryeval {
+namespace search::queryeval {
 namespace wand {
 
 template <typename FutureHeap, typename PastHeap, bool IS_STRICT>
-class WeakAndSearchLR : public WeakAndSearch
+class WeakAndSearchLR final : public WeakAndSearch
 {
 private:
     using Scores = vespalib::PriorityQueue<score_t>;
@@ -47,7 +46,7 @@ public:
         : _terms(terms,
                  TermFrequencyScorer(),
                  0,
-                 fef::MatchData::UP(nullptr)),
+                 fef::MatchData::UP()),
           _heaps(DocIdOrder(_terms.docId()), _terms.size()),
           _algo(),
           _threshold(1),
@@ -55,9 +54,9 @@ public:
           _n(n)
     {
     }
-    virtual size_t get_num_terms() const override { return _terms.size(); }
-    virtual int32_t get_term_weight(size_t idx) const override { return _terms.weight(idx); }
-    virtual score_t get_max_score(size_t idx) const override { return _terms.maxScore(idx); }
+    size_t get_num_terms() const override { return _terms.size(); }
+    int32_t get_term_weight(size_t idx) const override { return _terms.weight(idx); }
+    score_t get_max_score(size_t idx) const override { return _terms.maxScore(idx); }
     const Terms &getTerms() const override { return _terms.input_terms(); }
     uint32_t getN() const override { return _n; }
     void doSeek(uint32_t docid) override {
@@ -138,5 +137,4 @@ WeakAndSearch::create(const Terms &terms, uint32_t n, bool strict)
 
 //-----------------------------------------------------------------------------
 
-}  // namespace queryeval
-}  // namespace search
+}