From 39f1310b294b9fbd98dd65f8da58f959a5008418 Mon Sep 17 00:00:00 2001
From: Henning Baldersheim <balder@yahoo-inc.com>
Date: Thu, 25 Apr 2024 08:31:36 +0000
Subject: Add noexcept

---
 .../src/vespa/vespalib/btree/btreenodeallocator.h  | 32 +++++++--------
 .../vespa/vespalib/btree/btreenodeallocator.hpp    | 47 +++++++++-------------
 vespalib/src/vespa/vespalib/btree/btreenodestore.h | 28 ++++++-------
 .../src/vespa/vespalib/btree/btreenodestore.hpp    |  2 +-
 4 files changed, 51 insertions(+), 58 deletions(-)

(limited to 'vespalib')

diff --git a/vespalib/src/vespa/vespalib/btree/btreenodeallocator.h b/vespalib/src/vespa/vespalib/btree/btreenodeallocator.h
index e36d1507495..02d6d7f6969 100644
--- a/vespalib/src/vespa/vespalib/btree/btreenodeallocator.h
+++ b/vespalib/src/vespa/vespalib/btree/btreenodeallocator.h
@@ -54,7 +54,7 @@ public:
     BTreeNodeAllocator();
     ~BTreeNodeAllocator();
 
-    void disableFreeLists() {
+    void disableFreeLists() noexcept {
         _nodeStore.disableFreeLists();
     }
 
@@ -111,57 +111,57 @@ public:
 
     void reclaim_all_memory();
 
-    static bool isValidRef(BTreeNode::Ref ref) { return NodeStore::isValidRef(ref); }
+    static bool isValidRef(BTreeNode::Ref ref) noexcept { return NodeStore::isValidRef(ref); }
 
-    bool isLeafRef(BTreeNode::Ref ref) const {
+    bool isLeafRef(BTreeNode::Ref ref) const noexcept {
         if (!isValidRef(ref))
             return false;
         return _nodeStore.isLeafRef(ref);
     }
 
-    const InternalNodeType *mapInternalRef(BTreeNode::Ref ref) const {
+    const InternalNodeType *mapInternalRef(BTreeNode::Ref ref) const noexcept {
         return _nodeStore.mapInternalRef(ref);
     }
 
-    InternalNodeType *mapInternalRef(BTreeNode::Ref ref) {
+    InternalNodeType *mapInternalRef(BTreeNode::Ref ref) noexcept {
         return _nodeStore.mapInternalRef(ref);
     }
 
-    const LeafNodeType *mapLeafRef(BTreeNode::Ref ref) const {
+    const LeafNodeType *mapLeafRef(BTreeNode::Ref ref) const noexcept {
         return _nodeStore.mapLeafRef(ref);
     }
 
-    LeafNodeType *mapLeafRef(BTreeNode::Ref ref) {
+    LeafNodeType *mapLeafRef(BTreeNode::Ref ref) noexcept {
         return _nodeStore.mapLeafRef(ref);
     }
 
     template <typename NodeType>
-    const NodeType *mapRef(BTreeNode::Ref ref) const {
+    const NodeType *mapRef(BTreeNode::Ref ref) const noexcept {
         return _nodeStore.template mapRef<NodeType>(ref);
     }
 
     template <typename NodeType>
-    NodeType *mapRef(BTreeNode::Ref ref) {
+    NodeType *mapRef(BTreeNode::Ref ref) noexcept {
         return _nodeStore.template mapRef<NodeType>(ref);
     }
 
     InternalNodeTypeRefPair moveInternalNode(const InternalNodeType *node);
     LeafNodeTypeRefPair moveLeafNode(const LeafNodeType *node);
-    uint32_t validLeaves(BTreeNode::Ref ref) const;
+    uint32_t validLeaves(BTreeNode::Ref ref) const noexcept;
 
     /*
      * Extract level from ref.
      */
-    uint32_t getLevel(BTreeNode::Ref ref) const;
-    const KeyT &getLastKey(BTreeNode::Ref node) const;
-    const AggrT &getAggregated(BTreeNode::Ref node) const;
+    uint32_t getLevel(BTreeNode::Ref ref) const noexcept;
+    const KeyT &getLastKey(BTreeNode::Ref node) const noexcept;
+    const AggrT &getAggregated(BTreeNode::Ref node) const noexcept;
 
-    vespalib::MemoryUsage getMemoryUsage() const;
+    vespalib::MemoryUsage getMemoryUsage() const noexcept;
 
     vespalib::string toString(BTreeNode::Ref ref) const;
     vespalib::string toString(const BTreeNode * node) const;
 
-    bool getCompacting(EntryRef ref) { return _nodeStore.getCompacting(ref); }
+    bool getCompacting(EntryRef ref) noexcept { return _nodeStore.getCompacting(ref); }
 
     std::unique_ptr<vespalib::datastore::CompactingBuffers> start_compact_worst(const CompactionStrategy& compaction_strategy) { return _nodeStore.start_compact_worst(compaction_strategy); }
 
@@ -175,7 +175,7 @@ public:
         _nodeStore.foreach(ref, func);
     }
 
-    const NodeStore &getNodeStore() const { return _nodeStore; }
+    const NodeStore &getNodeStore() const noexcept { return _nodeStore; }
 };
 
 extern template class BTreeNodeAllocator<uint32_t, uint32_t, NoAggregated, BTreeDefaultTraits::INTERNAL_SLOTS, BTreeDefaultTraits::LEAF_SLOTS>;
diff --git a/vespalib/src/vespa/vespalib/btree/btreenodeallocator.hpp b/vespalib/src/vespa/vespalib/btree/btreenodeallocator.hpp
index 69db7ad579c..fcc086fe411 100644
--- a/vespalib/src/vespa/vespalib/btree/btreenodeallocator.hpp
+++ b/vespalib/src/vespa/vespalib/btree/btreenodeallocator.hpp
@@ -147,10 +147,9 @@ BTreeNode::Ref
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
 thawNode(BTreeNode::Ref node)
 {
-    if (isLeafRef(node))
-        return thawNode(node, mapLeafRef(node)).ref;
-    else
-        return thawNode(node, mapInternalRef(node)).ref;
+    return isLeafRef(node)
+        ? thawNode(node, mapLeafRef(node)).ref
+        : thawNode(node, mapInternalRef(node)).ref;
 }
 
 
@@ -158,8 +157,7 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 void
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-holdNode(BTreeNode::Ref nodeRef,
-         InternalNodeType *node)
+holdNode(BTreeNode::Ref nodeRef, InternalNodeType *node)
 {
     if (node->getFrozen()) {
         _nodeStore.hold_entry(nodeRef);
@@ -174,8 +172,7 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 void
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-holdNode(BTreeNode::Ref nodeRef,
-         LeafNodeType *node)
+holdNode(BTreeNode::Ref nodeRef, LeafNodeType *node)
 {
     if (node->getFrozen()) {
         _nodeStore.hold_entry(nodeRef);
@@ -318,12 +315,11 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 uint32_t
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-validLeaves(BTreeNode::Ref ref) const
+validLeaves(BTreeNode::Ref ref) const noexcept
 {
-    if (isLeafRef(ref))
-        return mapLeafRef(ref)->validSlots();
-    else
-        return mapInternalRef(ref)->validLeaves();
+    return isLeafRef(ref)
+        ? mapLeafRef(ref)->validSlots()
+        : mapInternalRef(ref)->validLeaves();
 }
 
 
@@ -331,12 +327,11 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 uint32_t
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-getLevel(BTreeNode::Ref ref) const
+getLevel(BTreeNode::Ref ref) const noexcept
 {
-    if (isLeafRef(ref))
-        return BTreeNode::LEAF_LEVEL;
-    else
-        return mapInternalRef(ref)->getLevel();
+    return isLeafRef(ref)
+        ? BTreeNode::LEAF_LEVEL
+        : mapInternalRef(ref)->getLevel();
 }
 
 
@@ -344,12 +339,11 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 const KeyT &
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-getLastKey(BTreeNode::Ref node) const
+getLastKey(BTreeNode::Ref node) const noexcept
 {
-    if (isLeafRef(node))
-        return mapLeafRef(node)->getLastKey();
-    else
-        return mapInternalRef(node)->getLastKey();
+    return isLeafRef(node)
+        ? mapLeafRef(node)->getLastKey()
+        : mapInternalRef(node)->getLastKey();
 }
 
 
@@ -357,7 +351,7 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 const AggrT &
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-getAggregated(BTreeNode::Ref node) const
+getAggregated(BTreeNode::Ref node) const noexcept
 {
     if (!node.valid())
         return LeafNodeType::getEmptyAggregated();
@@ -372,10 +366,9 @@ template <typename KeyT, typename DataT, typename AggrT,
           size_t INTERNAL_SLOTS, size_t LEAF_SLOTS>
 vespalib::MemoryUsage
 BTreeNodeAllocator<KeyT, DataT, AggrT, INTERNAL_SLOTS, LEAF_SLOTS>::
-getMemoryUsage() const
+getMemoryUsage() const noexcept
 {
-    vespalib::MemoryUsage usage = _nodeStore.getMemoryUsage();
-    return usage;
+    return _nodeStore.getMemoryUsage();
 }
 
 template <typename KeyT, typename DataT, typename AggrT,
diff --git a/vespalib/src/vespa/vespalib/btree/btreenodestore.h b/vespalib/src/vespa/vespalib/btree/btreenodestore.h
index ba316465d90..414d5adc572 100644
--- a/vespalib/src/vespa/vespalib/btree/btreenodestore.h
+++ b/vespalib/src/vespa/vespalib/btree/btreenodestore.h
@@ -13,7 +13,7 @@ namespace vespalib::btree {
 class BTreeNodeReclaimer
 {
 public:
-    static void reclaim(BTreeNode * node) {
+    static void reclaim(BTreeNode * node) noexcept {
         node->unFreeze();
     }
 };
@@ -78,44 +78,44 @@ public:
 
     ~BTreeNodeStore();
 
-    void disableFreeLists() { _store.disableFreeLists(); }
+    void disableFreeLists() noexcept { _store.disableFreeLists(); }
     void disable_entry_hold_list() { _store.disable_entry_hold_list(); }
 
-    static bool isValidRef(EntryRef ref) { return ref.valid(); }
+    static bool isValidRef(EntryRef ref) noexcept { return ref.valid(); }
 
-    bool isLeafRef(EntryRef ref) const {
+    bool isLeafRef(EntryRef ref) const noexcept {
         RefType iRef(ref);
         return _store.getTypeId(iRef.bufferId()) == NODETYPE_LEAF;
     }
 
-    const InternalNodeType *mapInternalRef(EntryRef ref) const {
+    const InternalNodeType *mapInternalRef(EntryRef ref) const noexcept {
         RefType iRef(ref);
         return _store.getEntry<InternalNodeType>(iRef);
     }
 
-    InternalNodeType *mapInternalRef(EntryRef ref) {
+    InternalNodeType *mapInternalRef(EntryRef ref) noexcept {
         RefType iRef(ref);
         return _store.getEntry<InternalNodeType>(iRef);
     }
 
-    const LeafNodeType *mapLeafRef(EntryRef ref) const {
+    const LeafNodeType *mapLeafRef(EntryRef ref) const noexcept {
         RefType iRef(ref);
         return _store.getEntry<LeafNodeType>(iRef);
     }
 
-    LeafNodeType *mapLeafRef(EntryRef ref) {
+    LeafNodeType *mapLeafRef(EntryRef ref) noexcept {
         RefType iRef(ref);
         return _store.getEntry<LeafNodeType>(iRef);
     }
 
     template <typename NodeType>
-    const NodeType *mapRef(EntryRef ref) const {
+    const NodeType *mapRef(EntryRef ref) const noexcept {
         RefType iRef(ref);
         return _store.getEntry<NodeType>(iRef);
     }
 
     template <typename NodeType>
-    NodeType *mapRef(EntryRef ref) {
+    NodeType *mapRef(EntryRef ref) noexcept {
         RefType iRef(ref);
         return _store.getEntry<NodeType>(iRef);
     }
@@ -163,7 +163,7 @@ public:
     }
 
     // Inherit doc from DataStoreBase
-    datastore::MemoryStats getMemStats() const {
+    datastore::MemoryStats getMemStats() const noexcept {
         return _store.getMemStats();
     }
 
@@ -177,16 +177,16 @@ public:
     }
 
     // Inherit doc from DataStoreBase
-    vespalib::MemoryUsage getMemoryUsage() const {
+    vespalib::MemoryUsage getMemoryUsage() const noexcept {
         return _store.getMemoryUsage();
     }
 
     // Inherit doc from DataStoreT
-    bool getCompacting(EntryRef ref) {
+    bool getCompacting(EntryRef ref) noexcept {
         return _store.getCompacting(ref);
     }
 
-    bool has_held_buffers() const {
+    bool has_held_buffers() const noexcept {
         return _store.has_held_buffers();
     }
 
diff --git a/vespalib/src/vespa/vespalib/btree/btreenodestore.hpp b/vespalib/src/vespa/vespalib/btree/btreenodestore.hpp
index 8c65838e65e..bc9a27af3ad 100644
--- a/vespalib/src/vespa/vespalib/btree/btreenodestore.hpp
+++ b/vespalib/src/vespa/vespalib/btree/btreenodestore.hpp
@@ -14,7 +14,7 @@ void
 BTreeNodeBufferType<EntryType>::initialize_reserved_entries(void *buffer, EntryCount reserved_entries)
 {
     ParentType::initialize_reserved_entries(buffer, reserved_entries);
-    EntryType *e = static_cast<EntryType *>(buffer);
+    auto *e = static_cast<EntryType *>(buffer);
     for (size_t j = reserved_entries; j != 0; --j) {
         e->freeze();
         ++e;
-- 
cgit v1.2.3