Clean up some todos.

17 files changed, 56 insertions, 65 deletions

diff --git a/storage/src/tests/bucketdb/lockablemaptest.cpp b/storage/src/tests/bucketdb/lockablemaptest.cpp
index 727f99fa9f2..34bba1b9798 100644
--- a/storage/src/tests/bucketdb/lockablemaptest.cpp
+++ b/storage/src/tests/bucketdb/lockablemaptest.cpp
@@ -252,7 +252,7 @@ TYPED_TEST(LockableMapTest, iterating) {
         EXPECT_EQ(A(4, 8, 0), *map.get(11, "foo"));
         EXPECT_EQ(A(1, 4, 3), *map.get(16, "foo"));
         auto entry = map.get(14, "foo");
-        EXPECT_FALSE(entry.exist());
+        EXPECT_FALSE(entry.exists());
     }
 }
 
@@ -742,7 +742,7 @@ TYPED_TEST(LockableMapTest, get_without_auto_create_does_not_implicitly_lock_buc
     BucketId id(16, 0x00001);
 
     auto entry = map.get(id.toKey(), "foo", false);
-    EXPECT_FALSE(entry.exist());
+    EXPECT_FALSE(entry.exists());
     EXPECT_FALSE(entry.preExisted());
     EXPECT_FALSE(entry.locked());
 }
@@ -752,7 +752,7 @@ TYPED_TEST(LockableMapTest, get_with_auto_create_returns_default_constructed_ent
     BucketId id(16, 0x00001);
 
     auto entry = map.get(id.toKey(), "foo", true);
-    EXPECT_TRUE(entry.exist());
+    EXPECT_TRUE(entry.exists());
     EXPECT_FALSE(entry.preExisted());
     EXPECT_TRUE(entry.locked());
     EXPECT_EQ(*entry, A());
@@ -761,7 +761,7 @@ TYPED_TEST(LockableMapTest, get_with_auto_create_returns_default_constructed_ent
 
     // Should now exist
     entry = map.get(id.toKey(), "foo", true);
-    EXPECT_TRUE(entry.exist());
+    EXPECT_TRUE(entry.exists());
     EXPECT_TRUE(entry.preExisted());
     EXPECT_TRUE(entry.locked());
     EXPECT_EQ(*entry, A(1, 2, 3));
diff --git a/storage/src/tests/persistence/common/filestortestfixture.cpp b/storage/src/tests/persistence/common/filestortestfixture.cpp
index 0b1eec30b2e..55a1b5d435b 100644
--- a/storage/src/tests/persistence/common/filestortestfixture.cpp
+++ b/storage/src/tests/persistence/common/filestortestfixture.cpp
@@ -62,7 +62,7 @@ bool
 FileStorTestFixture::bucketExistsInDb(const document::BucketId& bucket) const
 {
     StorBucketDatabase::WrappedEntry entry(_node->getStorageBucketDatabase().get(bucket, "bucketExistsInDb"));
-    return entry.exist();
+    return entry.exists();
 }
 
 FileStorTestFixture::TestFileStorComponents::TestFileStorComponents(
diff --git a/storage/src/tests/persistence/filestorage/deactivatebucketstest.cpp b/storage/src/tests/persistence/filestorage/deactivatebucketstest.cpp
index 6c9be3d1376..fa4a537bdb0 100644
--- a/storage/src/tests/persistence/filestorage/deactivatebucketstest.cpp
+++ b/storage/src/tests/persistence/filestorage/deactivatebucketstest.cpp
@@ -57,7 +57,7 @@ DeactivateBucketsTest::is_active(const document::BucketId& bucket) const
 {
     StorBucketDatabase::WrappedEntry entry(
             _node->getStorageBucketDatabase().get(bucket, "foo"));
-    assert(entry.exist());
+    assert(entry.exists());
     return entry->info.isActive();
 }
 
diff --git a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
index 4227f3dbe13..bbe2af732f5 100644
--- a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
+++ b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
@@ -1803,7 +1803,7 @@ TEST_F(FileStorManagerTest, GetBucketDiff_implicitly_creates_bucket) {
     EXPECT_EQ(api::ReturnCode(api::ReturnCode::OK), reply->getResult());
     {
         StorBucketDatabase::WrappedEntry entry(_node->getStorageBucketDatabase().get(bid, "foo"));
-        ASSERT_TRUE(entry.exist());
+        ASSERT_TRUE(entry.exists());
         EXPECT_TRUE(entry->info.isReady());
     }
 }
@@ -1826,7 +1826,7 @@ TEST_F(FileStorManagerTest, merge_bucket_implicitly_creates_bucket) {
     ASSERT_SINGLE_REPLY(api::GetBucketDiffCommand, diffCmd, top, _waitTime);
     {
         StorBucketDatabase::WrappedEntry entry(_node->getStorageBucketDatabase().get(bid, "foo"));
-        ASSERT_TRUE(entry.exist());
+        ASSERT_TRUE(entry.exists());
         EXPECT_TRUE(entry->info.isReady());
     }
 }
@@ -1848,7 +1848,7 @@ TEST_F(FileStorManagerTest, newly_created_bucket_is_ready) {
     EXPECT_EQ(api::ReturnCode(api::ReturnCode::OK), reply->getResult());
     {
         StorBucketDatabase::WrappedEntry entry(_node->getStorageBucketDatabase().get(bid, "foo"));
-        ASSERT_TRUE(entry.exist());
+        ASSERT_TRUE(entry.exists());
         EXPECT_TRUE(entry->info.isReady());
         EXPECT_FALSE(entry->info.isActive());
     }
@@ -1870,7 +1870,7 @@ TEST_F(FileStorManagerTest, create_bucket_sets_active_flag_in_database_and_reply
     EXPECT_EQ(api::ReturnCode(api::ReturnCode::OK), reply->getResult());
     {
         StorBucketDatabase::WrappedEntry entry(_node->getStorageBucketDatabase().get(bid, "foo"));
-        ASSERT_TRUE(entry.exist());
+        ASSERT_TRUE(entry.exists());
         EXPECT_TRUE(entry->info.isReady());
         EXPECT_TRUE(entry->info.isActive());
     }
diff --git a/storage/src/tests/persistence/filestorage/operationabortingtest.cpp b/storage/src/tests/persistence/filestorage/operationabortingtest.cpp
index 85816c3ad3e..386d2a66f64 100644
--- a/storage/src/tests/persistence/filestorage/operationabortingtest.cpp
+++ b/storage/src/tests/persistence/filestorage/operationabortingtest.cpp
@@ -338,7 +338,7 @@ OperationAbortingTest::getBucketInfoFromDB(const document::BucketId& id) const
 {
     StorBucketDatabase::WrappedEntry entry(
             _node->getStorageBucketDatabase().get(id, "foo", StorBucketDatabase::CREATE_IF_NONEXISTING));
-    assert(entry.exist());
+    assert(entry.exists());
     return entry->info;
 }
 
diff --git a/storage/src/tests/persistence/persistencetestutils.cpp b/storage/src/tests/persistence/persistencetestutils.cpp
index 7a92c08060c..b5a4c517357 100644
--- a/storage/src/tests/persistence/persistencetestutils.cpp
+++ b/storage/src/tests/persistence/persistencetestutils.cpp
@@ -160,7 +160,7 @@ PersistenceTestUtils::getBucketStatus(const document::BucketId& id)
                     id, "foo"));
 
     ost << id << ": ";
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         ost << "null";
     } else {
         ost << entry->getBucketInfo().getDocumentCount();
diff --git a/storage/src/vespa/storage/bucketdb/abstract_bucket_map.h b/storage/src/vespa/storage/bucketdb/abstract_bucket_map.h
index 7d3798a65a0..c14868b6aec 100644
--- a/storage/src/vespa/storage/bucketdb/abstract_bucket_map.h
+++ b/storage/src/vespa/storage/bucketdb/abstract_bucket_map.h
@@ -11,7 +11,6 @@
 #include <functional>
 #include <iosfwd>
 #include <map>
-#include <optional>
 
 namespace storage::bucketdb {
 
@@ -57,7 +56,7 @@ private:
             _map->unlock(_key);
             _map = nullptr;
         }
-        bool locked() const noexcept { return _map != nullptr; }
+        [[nodiscard]] bool locked() const noexcept { return _map != nullptr; }
         const key_type & key() const noexcept { return _key; }
     private:
         void cleanup() {
@@ -89,7 +88,6 @@ public:
               _clientId(clientId),
               _exists(false),
               _preExisted(false) {}
-        // TODO noexcept on these:
         WrappedEntry(WrappedEntry&&) noexcept = default;
         WrappedEntry& operator=(WrappedEntry&&) noexcept = default;
         ~WrappedEntry();
@@ -105,7 +103,7 @@ public:
         void write();
         void remove();
         void unlock();
-        [[nodiscard]] bool exist() const { return _exists; } // TODO rename to exists()
+        [[nodiscard]] bool exists() const { return _exists; }
         [[nodiscard]] bool preExisted() const { return _preExisted; }
         [[nodiscard]] bool locked() const { return _lockKeeper.locked(); }
         const key_type& getKey() const { return _lockKeeper.key(); };
@@ -171,7 +169,7 @@ public:
      * bucket to become inconsistent will require taking its lock, so by
      * requiring the lock to be provided here we avoid race conditions.
      */
-    virtual bool isConsistent(const WrappedEntry& entry) = 0; // TODO const
+    virtual bool isConsistent(const WrappedEntry& entry) const = 0;
 
     static constexpr uint32_t DEFAULT_CHUNK_SIZE = 1000;
 
@@ -185,16 +183,13 @@ public:
      *
      * Type erasure of functor needed due to virtual indirection.
      */
-    void for_each_chunked(std::function<Decision(uint64_t, const ValueT&)> func,
-                          const char* clientId,
-                          vespalib::duration yieldTime = 10us,
-                          uint32_t chunkSize = DEFAULT_CHUNK_SIZE)
+    void for_each_chunked(std::function<Decision(uint64_t, const ValueT&)> func, const char* clientId,
+                          vespalib::duration yieldTime = 10us, uint32_t chunkSize = DEFAULT_CHUNK_SIZE)
     {
         do_for_each_chunked(std::move(func), clientId, yieldTime, chunkSize);
     }
 
-    void for_each_mutable_unordered(std::function<Decision(uint64_t, ValueT&)> func,
-                                    const char* clientId)
+    void for_each_mutable_unordered(std::function<Decision(uint64_t, ValueT&)> func, const char* clientId)
     {
         do_for_each_mutable_unordered(std::move(func), clientId);
     }
@@ -217,14 +212,10 @@ public:
     virtual void print(std::ostream& out, bool verbose, const std::string& indent) const = 0;
 private:
     virtual void unlock(const key_type& key) = 0; // Only for bucket lock guards
-    virtual void do_for_each_chunked(std::function<Decision(uint64_t, const ValueT&)> func,
-                                     const char* clientId,
-                                     vespalib::duration yieldTime,
-                                     uint32_t chunkSize) = 0;
-    virtual void do_for_each_mutable_unordered(std::function<Decision(uint64_t, ValueT&)> func,
-                                               const char* clientId) = 0;
-    virtual void do_for_each(std::function<Decision(uint64_t, const ValueT&)> func,
-                             const char* clientId) = 0;
+    virtual void do_for_each_chunked(std::function<Decision(uint64_t, const ValueT&)> func, const char* clientId,
+                                     vespalib::duration yieldTime, uint32_t chunkSize) = 0;
+    virtual void do_for_each_mutable_unordered(std::function<Decision(uint64_t, ValueT&)> func, const char* clientId) = 0;
+    virtual void do_for_each(std::function<Decision(uint64_t, const ValueT&)> func, const char* clientId) = 0;
     virtual std::unique_ptr<bucketdb::ReadGuard<ValueT>> do_acquire_read_guard() const = 0;
 };
 
diff --git a/storage/src/vespa/storage/bucketdb/btree_lockable_map.h b/storage/src/vespa/storage/bucketdb/btree_lockable_map.h
index fdbd158864c..b1bb7aa95d6 100644
--- a/storage/src/vespa/storage/bucketdb/btree_lockable_map.h
+++ b/storage/src/vespa/storage/bucketdb/btree_lockable_map.h
@@ -69,7 +69,7 @@ public:
     void print(std::ostream& out, bool verbose, const std::string& indent) const override;
     EntryMap getContained(const BucketId& bucketId, const char* clientId) override;
     EntryMap getAll(const BucketId& bucketId, const char* clientId) override;
-    bool isConsistent(const WrappedEntry& entry) override;
+    bool isConsistent(const WrappedEntry& entry) const override;
     void showLockClients(vespalib::asciistream & out) const override;
 
 private:
diff --git a/storage/src/vespa/storage/bucketdb/btree_lockable_map.hpp b/storage/src/vespa/storage/bucketdb/btree_lockable_map.hpp
index e24e97ff2a4..6a37b771c48 100644
--- a/storage/src/vespa/storage/bucketdb/btree_lockable_map.hpp
+++ b/storage/src/vespa/storage/bucketdb/btree_lockable_map.hpp
@@ -551,7 +551,7 @@ BTreeLockableMap<T>::getAll(const BucketId& bucket, const char* clientId) {
 }
 
 template <typename T>
-bool BTreeLockableMap<T>::isConsistent(const BTreeLockableMap::WrappedEntry& entry) {
+bool BTreeLockableMap<T>::isConsistent(const BTreeLockableMap::WrappedEntry& entry) const {
     std::lock_guard guard(_lock);
     uint64_t n_buckets = 0;
     _impl->template find_parents_self_and_children<ByConstRef>(entry.getBucketId(),
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
index 67c6e936802..57d3c241cf0 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
@@ -619,7 +619,7 @@ BucketManager::verifyAndUpdateLastModified(api::StorageCommand& cmd,
     {
         StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(), "BucketManager::verify"));
 
-        if (entry.exist()) {
+        if (entry.exists()) {
             prevLastModified = entry->info.getLastModified();
 
             if (lastModified > prevLastModified) {
diff --git a/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.h b/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.h
index d7af9f8b6bd..9ad26c2c7f5 100644
--- a/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.h
+++ b/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.h
@@ -60,7 +60,7 @@ public:
     void print(std::ostream& out, bool verbose, const std::string& indent) const override;
     EntryMap getContained(const BucketId& bucketId, const char* clientId) override;
     EntryMap getAll(const BucketId& bucketId, const char* clientId) override;
-    bool isConsistent(const WrappedEntry& entry) override;
+    bool isConsistent(const WrappedEntry& entry) const override;
     void showLockClients(vespalib::asciistream & out) const override;
 
 private:
diff --git a/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.hpp b/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.hpp
index 2a14286c6b1..f7786c52f8f 100644
--- a/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.hpp
+++ b/storage/src/vespa/storage/bucketdb/striped_btree_lockable_map.hpp
@@ -125,7 +125,7 @@ StripedBTreeLockableMap<T>::getAll(const BucketId& bucket, const char* clientId)
 }
 
 template <typename T>
-bool StripedBTreeLockableMap<T>::isConsistent(const StripedBTreeLockableMap::WrappedEntry& entry) {
+bool StripedBTreeLockableMap<T>::isConsistent(const StripedBTreeLockableMap::WrappedEntry& entry) const {
     return db_for(entry.getKey()).isConsistent(entry);
 }
 
diff --git a/storage/src/vespa/storage/persistence/asynchandler.cpp b/storage/src/vespa/storage/persistence/asynchandler.cpp
index 42d44394f3a..a7bdeb5d2b7 100644
--- a/storage/src/vespa/storage/persistence/asynchandler.cpp
+++ b/storage/src/vespa/storage/persistence/asynchandler.cpp
@@ -221,7 +221,7 @@ AsyncHandler::handleDeleteBucket(api::DeleteBucketCommand& cmd, MessageTracker::
         (void) ignored;
         StorBucketDatabase &db(_env.getBucketDatabase(bucket.getBucketSpace()));
         StorBucketDatabase::WrappedEntry entry = db.get(bucket.getBucketId(), "onDeleteBucket");
-        if (entry.exist() && entry->getMetaCount() > 0) {
+        if (entry.exists() && entry->getMetaCount() > 0) {
             LOG(debug, "onDeleteBucket(%s): Bucket DB entry existed. Likely "
                        "active operation when delete bucket was queued. "
                        "Updating bucket database to keep it in sync with file. "
@@ -258,7 +258,7 @@ AsyncHandler::handleSetBucketState(api::SetBucketStateCommand& cmd, MessageTrack
         if (tracker->checkForError(*response)) {
             StorBucketDatabase &db(_env.getBucketDatabase(bucket.getBucketSpace()));
             StorBucketDatabase::WrappedEntry entry = db.get(bucket.getBucketId(),"handleSetBucketState");
-            if (entry.exist()) {
+            if (entry.exists()) {
                 entry->info.setActive(newState == spi::BucketInfo::ACTIVE);
                 notifyGuard->notifyIfOwnershipChanged(cmd.getBucket(), cmd.getSourceIndex(), entry->info);
                 entry.write();
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
index f6b7c7e5f0b..da9d16c9356 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
@@ -285,7 +285,7 @@ FileStorManager::mapOperationToDisk(api::StorageMessage& msg, const document::Bu
 {
     StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(
             bucket.getBucketId(), "FileStorManager::mapOperationToDisk"));
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         replyWithBucketNotFound(msg, bucket);
     }
     return entry;
@@ -297,7 +297,7 @@ FileStorManager::mapOperationToBucketAndDisk(api::BucketCommand& cmd, const docu
     StorBucketDatabase &database = _component.getBucketDatabase(cmd.getBucket().getBucketSpace());
     StorBucketDatabase::WrappedEntry entry(database.get(
             cmd.getBucketId(), "FileStorManager::mapOperationToBucketAndDisk"));
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         document::BucketId specific(cmd.getBucketId());
         if (docId) {
             specific = _bucketIdFactory.getBucketId(*docId);
@@ -393,7 +393,7 @@ FileStorManager::onPut(const shared_ptr<api::PutCommand>& cmd)
         return true;
     }
     StorBucketDatabase::WrappedEntry entry(mapOperationToBucketAndDisk(*cmd, &cmd->getDocumentId()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -412,7 +412,7 @@ FileStorManager::onUpdate(const shared_ptr<api::UpdateCommand>& cmd)
         return true;
     }
     StorBucketDatabase::WrappedEntry entry(mapOperationToBucketAndDisk(*cmd, &cmd->getDocumentId()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -422,7 +422,7 @@ bool
 FileStorManager::onGet(const shared_ptr<api::GetCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToBucketAndDisk(*cmd, &cmd->getDocumentId()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -441,7 +441,7 @@ FileStorManager::onRemove(const shared_ptr<api::RemoveCommand>& cmd)
         return true;
     }
     StorBucketDatabase::WrappedEntry entry(mapOperationToBucketAndDisk(*cmd, &cmd->getDocumentId()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -451,7 +451,7 @@ bool
 FileStorManager::onRevert(const shared_ptr<api::RevertCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToBucketAndDisk(*cmd, 0));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -461,7 +461,7 @@ bool
 FileStorManager::onRemoveLocation(const std::shared_ptr<api::RemoveLocationCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -471,7 +471,7 @@ bool
 FileStorManager::onStatBucket(const std::shared_ptr<api::StatBucketCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -519,7 +519,7 @@ FileStorManager::onDeleteBucket(const shared_ptr<api::DeleteBucketCommand>& cmd)
         document::Bucket bucket(cmd->getBucket());
         StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(),
                                                                                   "FileStorManager::onDeleteBucket"));
-        if (!entry.exist()) {
+        if (!entry.exists()) {
             LOG(debug, "%s was already deleted", cmd->getBucketId().toString().c_str());
             std::shared_ptr<api::StorageReply> reply = cmd->makeReply();
             sendUp(reply);
@@ -576,7 +576,7 @@ FileStorManager::ensureConsistentBucket(
 {
     StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(
                     bucket.getBucketId(), callerId, StorBucketDatabase::CREATE_IF_NONEXISTING));
-    assert(entry.exist());
+    assert(entry.exists());
     if (!_component.getBucketDatabase(bucket.getBucketSpace()).isConsistent(entry)) {
         if (!entry.preExisted()) {
             // Don't create empty bucket if merge isn't allowed to continue.
@@ -593,7 +593,7 @@ bool
 FileStorManager::onMergeBucket(const shared_ptr<api::MergeBucketCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(ensureConsistentBucket(cmd->getBucket(), *cmd, "FileStorManager::onMergeBucket"));
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         return true;
     }
 
@@ -615,7 +615,7 @@ bool
 FileStorManager::onGetBucketDiff(const shared_ptr<api::GetBucketDiffCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(ensureConsistentBucket(cmd->getBucket(), *cmd, "FileStorManager::onGetBucketDiff"));
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         return true;
     }
     if (!entry.preExisted()) {
@@ -637,7 +637,7 @@ FileStorManager::onGetBucketDiff(const shared_ptr<api::GetBucketDiffCommand>& cm
 bool
 FileStorManager::validateApplyDiffCommandBucket(api::StorageMessage& msg, const StorBucketDatabase::WrappedEntry& entry)
 {
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         return false;
     }
     BucketSpace bucketSpace(msg.getBucket().getBucketSpace());
@@ -653,7 +653,7 @@ bool
 FileStorManager::validateDiffReplyBucket(const StorBucketDatabase::WrappedEntry& entry,
                                          const document::Bucket& bucket)
 {
-    if (!entry.exist()) {
+    if (!entry.exists()) {
         _filestorHandler->clearMergeStatus(bucket,
                 api::ReturnCode(api::ReturnCode::BUCKET_NOT_FOUND, "Bucket removed during merge"));
         return false;
@@ -709,7 +709,7 @@ bool
 FileStorManager::onSplitBucket(const std::shared_ptr<api::SplitBucketCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -719,7 +719,7 @@ bool
 FileStorManager::onSetBucketState(const std::shared_ptr<api::SetBucketStateCommand>& cmd)
 {
     StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-    if (entry.exist()) {
+    if (entry.exists()) {
         handlePersistenceMessage(cmd);
     }
     return true;
@@ -733,7 +733,7 @@ FileStorManager::onInternal(const shared_ptr<api::InternalCommand>& msg)
     {
         shared_ptr<GetIterCommand> cmd(std::static_pointer_cast<GetIterCommand>(msg));
         StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-        if (entry.exist()) {
+        if (entry.exists()) {
             handlePersistenceMessage(cmd);
         }
         return true;
@@ -742,7 +742,7 @@ FileStorManager::onInternal(const shared_ptr<api::InternalCommand>& msg)
     {
         shared_ptr<CreateIteratorCommand> cmd(std::static_pointer_cast<CreateIteratorCommand>(msg));
         StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-        if (entry.exist()) {
+        if (entry.exists()) {
             handlePersistenceMessage(cmd);
         }
         return true;
@@ -765,7 +765,7 @@ FileStorManager::onInternal(const shared_ptr<api::InternalCommand>& msg)
     {
         shared_ptr<ReadBucketInfo> cmd(std::static_pointer_cast<ReadBucketInfo>(msg));
         StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-        if (entry.exist()) {
+        if (entry.exists()) {
             handlePersistenceMessage(cmd);
         }
         return true;
@@ -774,7 +774,7 @@ FileStorManager::onInternal(const shared_ptr<api::InternalCommand>& msg)
     {
         shared_ptr<RecheckBucketInfoCommand> cmd(std::static_pointer_cast<RecheckBucketInfoCommand>(msg));
         StorBucketDatabase::WrappedEntry entry(mapOperationToDisk(*cmd, cmd->getBucket()));
-        if (entry.exist()) {
+        if (entry.exists()) {
             handlePersistenceMessage(cmd);
         }
         return true;
@@ -1061,7 +1061,7 @@ void
 FileStorManager::execute(const spi::Bucket &bucket, std::unique_ptr<spi::BucketTask> task) {
     StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(
             bucket.getBucketId(), "FileStorManager::execute"));
-    if (entry.exist()) {
+    if (entry.exists()) {
         auto cmd = std::make_shared<RunTaskCommand>(bucket, std::move(task));
         _filestorHandler->schedule(cmd);
     } else {
diff --git a/storage/src/vespa/storage/persistence/mergehandler.cpp b/storage/src/vespa/storage/persistence/mergehandler.cpp
index 684c21e4c3e..dcc3602c5e7 100644
--- a/storage/src/vespa/storage/persistence/mergehandler.cpp
+++ b/storage/src/vespa/storage/persistence/mergehandler.cpp
@@ -189,7 +189,7 @@ MergeHandler::buildBucketInfoList(
         StorBucketDatabase& db(_env.getBucketDatabase(bucket.getBucketSpace()));
         StorBucketDatabase::WrappedEntry entry(
                 db.get(bucket.getBucketId(), "MergeHandler::buildBucketInfoList"));
-        if (entry.exist()) {
+        if (entry.exists()) {
             spi::BucketInfoResult infoResult(_spi.getBucketInfo(bucket));
 
             if (infoResult.getErrorCode() != spi::Result::ErrorType::NONE) {
diff --git a/storage/src/vespa/storage/persistence/persistenceutil.cpp b/storage/src/vespa/storage/persistence/persistenceutil.cpp
index e8534e3f299..203af1e04f3 100644
--- a/storage/src/vespa/storage/persistence/persistenceutil.cpp
+++ b/storage/src/vespa/storage/persistence/persistenceutil.cpp
@@ -191,7 +191,7 @@ PersistenceUtil::updateBucketDatabase(const document::Bucket &bucket, const api:
     // Update bucket database
     StorBucketDatabase::WrappedEntry entry(getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(),
                                                                                           "env::updatebucketdb"));
-    if (entry.exist()) {
+    if (entry.exists()) {
         api::BucketInfo info = i;
 
         // Don't override last modified unless this is the first bucket
diff --git a/storage/src/vespa/storage/persistence/splitjoinhandler.cpp b/storage/src/vespa/storage/persistence/splitjoinhandler.cpp
index 51fa1f1b785..79df09bbc5f 100644
--- a/storage/src/vespa/storage/persistence/splitjoinhandler.cpp
+++ b/storage/src/vespa/storage/persistence/splitjoinhandler.cpp
@@ -132,7 +132,7 @@ SplitJoinHandler::handleSplitBucket(api::SplitBucketCommand& cmd, MessageTracker
             target.first.remove();
         }
     }
-    if (sourceEntry.exist()) {
+    if (sourceEntry.exists()) {
         if (ownershipChanged) {
             notifyGuard.notifyAlways(cmd.getBucket(), sourceEntry->getBucketInfo());
         }
@@ -154,7 +154,7 @@ SplitJoinHandler::handleRecheckBucketInfo(RecheckBucketInfoCommand& cmd, Message
         StorBucketDatabase::WrappedEntry entry(
                 _env.getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(), "handleRecheckBucketInfo"));
 
-        if (entry.exist()) {
+        if (entry.exists()) {
             api::BucketInfo prevInfo(entry->getBucketInfo());
 
             if (!(prevInfo == info)) {
@@ -214,7 +214,7 @@ SplitJoinHandler::handleJoinBuckets(api::JoinBucketsCommand& cmd, MessageTracker
         // Remove source from bucket db.
         StorBucketDatabase::WrappedEntry entry =
                 _env.getBucketDatabase(srcBucket.getBucketSpace()).get(srcBucket.getBucketId(), "join-remove-source");
-        if (entry.exist()) {
+        if (entry.exists()) {
             lastModified = std::max(lastModified, entry->info.getLastModified());
             entry.remove();
         }