Merge pull request #31048 from vespa-engine/balder/add-noexcept-5

Add noexcept

6 files changed, 72 insertions, 86 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.cpp b/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.cpp
index 93bc4735916..3bd1682c470 100644
--- a/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.cpp
@@ -10,20 +10,13 @@ template <typename IteratorType, typename RefType>
 PostingIteratorPack<IteratorType, RefType>::~PostingIteratorPack() = default;
 
 template <typename IteratorType, typename RefType>
-PostingIteratorPack<IteratorType, RefType>::PostingIteratorPack(std::vector<IteratorType> &&children)
+PostingIteratorPack<IteratorType, RefType>::PostingIteratorPack(std::vector<IteratorType> &&children) noexcept
     : _children(std::move(children))
 {
     assert(_children.size() <= std::numeric_limits<ref_t>::max());
 }
 
 template <typename IteratorType, typename RefType>
-bool
-PostingIteratorPack<IteratorType, RefType>::can_handle_iterators(size_t num_iterators)
-{
-    return num_iterators <= std::numeric_limits<ref_t>::max();
-}
-
-template <typename IteratorType, typename RefType>
 std::unique_ptr<BitVector>
 PostingIteratorPack<IteratorType, RefType>::get_hits(uint32_t begin_id, uint32_t end_id) {
     BitVector::UP result(BitVector::create(begin_id, end_id));
@@ -48,14 +41,14 @@ PostingIteratorPack<IteratorType, RefType>::or_hits_into(BitVector &result, uint
 
 template <>
 int32_t
-PostingIteratorPack<DocidIterator, uint16_t>::get_weight(ref_t, uint32_t)
+PostingIteratorPack<DocidIterator, uint16_t>::get_weight(ref_t, uint32_t) noexcept
 {
     return 1;
 }
 
 template <>
 int32_t
-PostingIteratorPack<DocidIterator, uint32_t>::get_weight(ref_t, uint32_t)
+PostingIteratorPack<DocidIterator, uint32_t>::get_weight(ref_t, uint32_t) noexcept
 {
     return 1;
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.h b/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.h
index 7c6b85dd3ec..ce0163dc293 100644
--- a/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.h
+++ b/searchlib/src/vespa/searchlib/attribute/posting_iterator_pack.h
@@ -23,16 +23,18 @@ public:
     PostingIteratorPack(PostingIteratorPack &&rhs) noexcept = default;
     PostingIteratorPack &operator=(PostingIteratorPack &&rhs) noexcept = default;
 
-    explicit PostingIteratorPack(std::vector<IteratorType> &&children);
+    explicit PostingIteratorPack(std::vector<IteratorType> &&children) noexcept;
     ~PostingIteratorPack();
 
-    static bool can_handle_iterators(size_t num_iterators);
+    constexpr static bool can_handle_iterators(size_t num_iterators) noexcept {
+        return num_iterators <= std::numeric_limits<ref_t>::max();
+    }
 
-    uint32_t get_docid(ref_t ref) const {
+    uint32_t get_docid(ref_t ref) const noexcept {
         return _children[ref].valid() ? _children[ref].getKey() : endDocId;
     }
 
-    uint32_t seek(ref_t ref, uint32_t docid) {
+    uint32_t seek(ref_t ref, uint32_t docid) noexcept {
         _children[ref].linearSeek(docid);
         if (__builtin_expect(_children[ref].valid(), true)) {
             return _children[ref].getKey();
@@ -40,7 +42,7 @@ public:
         return endDocId;
     }
 
-    int32_t get_weight(ref_t ref, uint32_t) {
+    int32_t get_weight(ref_t ref, uint32_t) noexcept {
         return _children[ref].getData();
     }
 
@@ -48,14 +50,14 @@ public:
     void or_hits_into(BitVector &result, uint32_t begin_id);
 
     ref_t size() const noexcept { return _children.size(); }
-    void initRange(uint32_t begin, uint32_t end) {
+    void initRange(uint32_t begin, uint32_t end) noexcept {
         (void) end;
         for (auto &child: _children) {
             child.lower_bound(begin);
         }
     }
 private:
-    uint32_t next(ref_t ref) {
+    uint32_t next(ref_t ref) noexcept {
         ++_children[ref];
         return get_docid(ref);
     }
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 f3028f5159a..9e887b9d0f7 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
@@ -14,7 +14,6 @@ using vespalib::make_string;
 namespace search::queryeval {
 
 using MatchParams = ParallelWeakAndSearch::MatchParams;
-using RankParams = ParallelWeakAndSearch::RankParams;
 
 namespace wand {
 
@@ -22,7 +21,7 @@ namespace { bool should_monitor_wand() { return LOG_WOULD_LOG(spam); } }
 
 
 template <typename VectorizedTerms, typename FutureHeap, typename PastHeap, bool IS_STRICT>
-class ParallelWeakAndSearchImpl : public ParallelWeakAndSearch
+class ParallelWeakAndSearchImpl final : public ParallelWeakAndSearch
 {
 private:
     fef::TermFieldMatchData       &_tfmd;
@@ -120,8 +119,7 @@ insertMonitoringSearchIterator(const wand::Terms &terms)
     for (size_t i = 0; i < terms.size(); ++i) {
         wand::Term &t = retval[i];
         t.search = new MonitoringSearchIterator
-            (make_string("w%d:e%u:m%" PRId64 "",
-                         t.weight, t.estHits, DotProductScorer::calculateMaxScore(t)),
+            (make_string("w%d:e%u:m%" PRId64 "", t.weight, t.estHits, DotProductScorer::calculateMaxScore(t)),
              SearchIterator::UP(t.search), true);
     }
     return retval;
@@ -167,11 +165,9 @@ ParallelWeakAndSearch::createArrayWand(const Terms &terms,
                                        RankParams &&rankParams,
                                        bool strict)
 {
-    if (strict) {
-        return wand::createWand<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>(terms, matchParams, std::move(rankParams));
-    } else {
-        return wand::createWand<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>(terms, matchParams, std::move(rankParams));
-    }
+    return strict
+        ? wand::createWand<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>(terms, matchParams, std::move(rankParams))
+        : wand::createWand<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>(terms, matchParams, std::move(rankParams));
 }
 
 SearchIterator::UP
@@ -180,11 +176,9 @@ ParallelWeakAndSearch::createHeapWand(const Terms &terms,
                                       RankParams &&rankParams,
                                       bool strict)
 {
-    if (strict) {
-        return wand::createWand<vespalib::LeftHeap, vespalib::RightHeap, true>(terms, matchParams, std::move(rankParams));
-    } else {
-        return wand::createWand<vespalib::LeftHeap, vespalib::RightHeap, false>(terms, matchParams, std::move(rankParams));
-    }
+    return strict
+        ? wand::createWand<vespalib::LeftHeap, vespalib::RightHeap, true>(terms, matchParams, std::move(rankParams))
+        : wand::createWand<vespalib::LeftHeap, vespalib::RightHeap, false>(terms, matchParams, std::move(rankParams));
 }
 
 SearchIterator::UP
@@ -193,11 +187,9 @@ ParallelWeakAndSearch::create(const Terms &terms,
                               RankParams &&rankParams,
                               bool strict)
 {
-    if (terms.size() < 128) {
-        return createArrayWand(terms, matchParams, std::move(rankParams), strict);
-    } else {
-        return createHeapWand(terms, matchParams, std::move(rankParams), strict);
-    }
+    return (terms.size() < 128)
+        ? createArrayWand(terms, matchParams, std::move(rankParams), strict)
+        : createHeapWand(terms, matchParams, std::move(rankParams), strict);
 }
 
 //-----------------------------------------------------------------------------
@@ -206,9 +198,11 @@ namespace {
 
 template <typename VectorizedTerms, typename FutureHeap, typename PastHeap>
 SearchIterator::UP create_helper(search::fef::TermFieldMatchData &tfmd, VectorizedTerms &&terms, const MatchParams &params, bool strict) {
-    return (strict)
-        ? SearchIterator::UP(new wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, true>(tfmd, std::move(terms), params))
-        : SearchIterator::UP( new wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, false>(tfmd, std::move(terms), params));
+    if (strict) {
+        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, true>>(tfmd, std::move(terms), params);
+    } else {
+        return std::make_unique<wand::ParallelWeakAndSearchImpl<VectorizedTerms, FutureHeap, PastHeap, false>>(tfmd, std::move(terms), params);
+    }
 }
 
 template <typename VectorizedTerms>
@@ -236,19 +230,20 @@ ParallelWeakAndSearch::create(search::fef::TermFieldMatchData &tfmd,
         // reverse-wrap direct iterators into old API to be compatible with monitoring
         fef::MatchDataLayout layout;
         std::vector<fef::TermFieldHandle> handles;
+        handles.reserve(weights.size());
         for (size_t i = 0; i < weights.size(); ++i) {
             handles.push_back(layout.allocTermField(tfmd.getFieldId()));
         }
         fef::MatchData::UP childrenMatchData = layout.createMatchData();
         assert(childrenMatchData->getNumTermFields() == dict_entries.size());
         wand::Terms terms;
+        terms.reserve(dict_entries.size());
         for (size_t i = 0; i < dict_entries.size(); ++i) {
-            terms.push_back(wand::Term(new DocidWithWeightSearchIterator(*(childrenMatchData->resolveTermField(handles[i])), attr, dict_entries[i]),
-                                       weights[i],
-                                       dict_entries[i].posting_size,
-                                       childrenMatchData->resolveTermField(handles[i])));
+            terms.emplace_back(new DocidWithWeightSearchIterator(*(childrenMatchData->resolveTermField(handles[i])), attr, dict_entries[i]),
+                               weights[i],
+                               dict_entries[i].posting_size,
+                               childrenMatchData->resolveTermField(handles[i]));
         }
-        assert(terms.size() == dict_entries.size());
         return create(terms, matchParams, RankParams(tfmd, std::move(childrenMatchData)), strict);
     }
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
index 9431b527510..ed8d4b4e4ac 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
@@ -26,7 +26,6 @@ using ref_t = uint16_t;
 
 using Attr = IDirectPostingStore;
 using AttrDictEntry = Attr::LookupResult;
-using AttrDictEntries = std::vector<AttrDictEntry>;
 
 //-----------------------------------------------------------------------------
 
@@ -55,14 +54,14 @@ struct Term {
 namespace {
 
 struct Ident {
-    template <typename T> T operator()(const T &t) const { return t; }
+    template <typename T> T operator()(const T &t) const noexcept { return t; }
 };
 
 struct NumericOrder {
     size_t my_size;
-    NumericOrder(size_t my_size_in) : my_size(my_size_in) {}
-    size_t size() const { return my_size; }
-    ref_t operator[](size_t idx) const { return idx; }
+    explicit NumericOrder(size_t my_size_in) noexcept : my_size(my_size_in) {}
+    size_t size() const noexcept { return my_size; }
+    ref_t operator[](size_t idx) const noexcept { return idx; }
 };
 
 template <typename F, typename Order>
@@ -84,25 +83,25 @@ int32_t get_max_weight(const SearchIterator &search) {
 
 struct TermInput {
     const Terms &terms;
-    TermInput(const Terms &terms_in) : terms(terms_in) {}
-    size_t size() const { return terms.size(); }
-    int32_t get_weight(ref_t ref) const { return terms[ref].weight; }
-    uint32_t get_est_hits(ref_t ref) const { return terms[ref].estHits; }
-    int32_t get_max_weight(ref_t ref) const { return ::search::queryeval::wand::get_max_weight(*(terms[ref].search)); }
-    docid_t get_initial_docid(ref_t ref) const { return terms[ref].search->getDocId(); }
+    explicit TermInput(const Terms &terms_in) noexcept : terms(terms_in) {}
+    size_t size() const noexcept  { return terms.size(); }
+    int32_t get_weight(ref_t ref) const noexcept { return terms[ref].weight; }
+    uint32_t get_est_hits(ref_t ref) const noexcept { return terms[ref].estHits; }
+    int32_t get_max_weight(ref_t ref) const noexcept { return ::search::queryeval::wand::get_max_weight(*(terms[ref].search)); }
+    docid_t get_initial_docid(ref_t ref) const noexcept { return terms[ref].search->getDocId(); }
 };
 
 struct AttrInput {
     const std::vector<int32_t> &weights;
     const std::vector<IDirectPostingStore::LookupResult> &dict_entries;
     AttrInput(const std::vector<int32_t> &weights_in,
-              const std::vector<IDirectPostingStore::LookupResult> &dict_entries_in)
+              const std::vector<IDirectPostingStore::LookupResult> &dict_entries_in) noexcept
         : weights(weights_in), dict_entries(dict_entries_in) {}
-    size_t size() const { return weights.size(); }
-    int32_t get_weight(ref_t ref) const { return weights[ref]; }
-    uint32_t get_est_hits(ref_t ref) const { return dict_entries[ref].posting_size; }
-    int32_t get_max_weight(ref_t ref) const { return dict_entries[ref].max_weight; }
-    docid_t get_initial_docid(ref_t) const { return SearchIterator::beginId(); }
+    size_t size() const noexcept { return weights.size(); }
+    int32_t get_weight(ref_t ref) const noexcept { return weights[ref]; }
+    uint32_t get_est_hits(ref_t ref) const noexcept { return dict_entries[ref].posting_size; }
+    int32_t get_max_weight(ref_t ref) const noexcept { return dict_entries[ref].max_weight; }
+    docid_t get_initial_docid(ref_t) const noexcept { return SearchIterator::beginId(); }
 };
 
 template <typename Input>
@@ -111,7 +110,7 @@ struct MaxSkipOrder {
     const Input &input;
     const std::vector<score_t> &max_score;
     MaxSkipOrder(docid_t docIdLimit, const Input &input_in,
-                 const std::vector<score_t> &max_score_in)
+                 const std::vector<score_t> &max_score_in) noexcept
         : estNumDocs(1.0), input(input_in), max_score(max_score_in)
     {
         estNumDocs = std::max(estNumDocs, docIdLimit - 1.0);
@@ -119,10 +118,10 @@ struct MaxSkipOrder {
             estNumDocs = std::max(estNumDocs, (double)input.get_est_hits(i));
         }
     }
-    double p_not_hit(double estHits) const {
+    double p_not_hit(double estHits) const noexcept {
         return ((estNumDocs - estHits) / (estNumDocs));
     }
-    bool operator()(ref_t a, ref_t b) const {
+    bool operator()(ref_t a, ref_t b) const noexcept {
         return ((p_not_hit(input.get_est_hits(a)) * max_score[a]) > (p_not_hit(input.get_est_hits(b)) * max_score[b]));
     }
 };
@@ -158,7 +157,7 @@ private:
     IteratorPack         _iteratorPack;
 
 public:
-    VectorizedState();
+    VectorizedState() noexcept;
     VectorizedState(VectorizedState &&) noexcept;
     VectorizedState & operator=(VectorizedState &&) noexcept;
     ~VectorizedState();
@@ -184,7 +183,7 @@ public:
 };
 
 template <typename IteratorPack>
-VectorizedState<IteratorPack>::VectorizedState()
+VectorizedState<IteratorPack>::VectorizedState() noexcept
     : _docId(),
       _weight(),
       _maxScore(),
@@ -292,10 +291,10 @@ struct VectorizedAttributeTerms : VectorizedState<DocidWithWeightIteratorPack> {
  **/
 struct DocIdOrder {
     const docid_t *termPos;
-    DocIdOrder(docid_t *pos) : termPos(pos) {}
-    bool at_end(ref_t ref) const { return termPos[ref] == search::endDocId; }
-    docid_t get_pos(ref_t ref) const { return termPos[ref]; }
-    bool operator()(ref_t a, ref_t b) const {
+    explicit DocIdOrder(docid_t *pos) noexcept : termPos(pos) {}
+    bool at_end(ref_t ref) const noexcept { return termPos[ref] == search::endDocId; }
+    docid_t get_pos(ref_t ref) const noexcept { return termPos[ref]; }
+    bool operator()(ref_t a, ref_t b) const noexcept {
         return (termPos[a] < termPos[b]);
     }
 };
@@ -358,7 +357,7 @@ DualHeap<FutureHeap, PastHeap>::DualHeap(const DocIdOrder &futureCmp, size_t siz
 }
 
 template <typename FutureHeap, typename PastHeap>
-DualHeap<FutureHeap, PastHeap>::~DualHeap() { }
+DualHeap<FutureHeap, PastHeap>::~DualHeap() = default;
 
 template <typename FutureHeap, typename PastHeap>
 void
@@ -399,11 +398,11 @@ DualHeap<FutureHeap, PastHeap>::stringify() const {
 struct TermFrequencyScorer
 {
     // weight * idf, scaled to fixedpoint
-    static score_t calculateMaxScore(double estHits, double weight) {
+    static score_t calculateMaxScore(double estHits, double weight) noexcept {
         return (score_t) (TermFrequencyScorer_TERM_SCORE_FACTOR * weight / (1.0 + log(1.0 + (estHits / 1000.0))));
     }
 
-    static score_t calculateMaxScore(const Term &term) {
+    static score_t calculateMaxScore(const Term &term) noexcept {
         return calculateMaxScore(term.estHits, term.weight) + 1;
     }
 
@@ -424,9 +423,9 @@ struct DotProductScorer
     static score_t calculateMaxScore(const Term &term) {
         int32_t maxWeight = std::numeric_limits<int32_t>::max();
         const PostingInfo *postingInfo = term.search->getPostingInfo();
-        if (postingInfo != NULL) {
-            const MinMaxPostingInfo *minMax = dynamic_cast<const MinMaxPostingInfo *>(postingInfo);
-            if (minMax != NULL) {
+        if (postingInfo != nullptr) {
+            const auto *minMax = dynamic_cast<const MinMaxPostingInfo *>(postingInfo);
+            if (minMax != nullptr) {
                 maxWeight = minMax->getMaxWeight();
             }
         }
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 f915a7df335..375a6598b49 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
@@ -109,9 +109,9 @@ SearchIterator::UP
 WeakAndSearch::createArrayWand(const Terms &terms, uint32_t n, bool strict)
 {
     if (strict) {
-        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>(terms, n));
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>>(terms, n);
     } else {
-        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>(terms, n));
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>>(terms, n);
     }
 }
 
@@ -119,9 +119,9 @@ SearchIterator::UP
 WeakAndSearch::createHeapWand(const Terms &terms, uint32_t n, bool strict)
 {
     if (strict) {
-        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>(terms, n));
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>>(terms, n);
     } else {
-        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>(terms, n));
+        return std::make_unique<wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>>(terms, n);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
index cda5f4c4232..6a56a04887c 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
@@ -2,11 +2,10 @@
 
 #pragma once
 
-#include <vespa/searchlib/queryeval/searchiterator.h>
 #include "wand_parts.h"
+#include <vespa/searchlib/queryeval/searchiterator.h>
 
-namespace search {
-namespace queryeval {
+namespace search::queryeval {
 
 struct WeakAndSearch : SearchIterator {
     using Terms = wand::Terms;
@@ -21,6 +20,4 @@ struct WeakAndSearch : SearchIterator {
     static SearchIterator::UP create(const Terms &terms, uint32_t n, bool strict);
 };
 
-} // namespace queryeval
-} // namespace search
-
+}