remove most usage of LinkedPtr from vespa

10 files changed, 86 insertions, 90 deletions

diff --git a/persistence/src/main/java/com/yahoo/persistence/spi/conformance/ConformanceTest.java b/persistence/src/main/java/com/yahoo/persistence/spi/conformance/ConformanceTest.java
index 80aedc3263d..58a494a7e4d 100644
--- a/persistence/src/main/java/com/yahoo/persistence/spi/conformance/ConformanceTest.java
+++ b/persistence/src/main/java/com/yahoo/persistence/spi/conformance/ConformanceTest.java
@@ -1497,7 +1497,7 @@ public abstract class ConformanceTest extends TestCase {
 //            }
 //
 //            size_t
-//            getRemoveEntryCount(const std::vector<spi::DocEntry::LP>& entries)
+//            getRemoveEntryCount(const std::vector<spi::DocEntry::UP>& entries)
 //            {
 //                size_t ret = 0;
 //                for (size_t i = 0; i < entries.size(); ++i) {
@@ -1511,7 +1511,7 @@ public abstract class ConformanceTest extends TestCase {
 //            List<DocEntry>
 //                    getEntriesFromChunks(const std::vector<Chunk>& chunks)
 //            {
-//                std::vector<spi::DocEntry::LP> ret;
+//                std::vector<spi::DocEntry::UP> ret;
 //                for (size_t chunk = 0; chunk < chunks.size(); ++chunk) {
 //                    for (size_t i = 0; i < chunks[chunk]._entries.size(); ++i) {
 //                        ret.push_back(chunks[chunk]._entries[i]);
diff --git a/persistence/src/tests/dummyimpl/dummypersistence_test.cpp b/persistence/src/tests/dummyimpl/dummypersistence_test.cpp
index 1a7c43db600..a408eec739f 100644
--- a/persistence/src/tests/dummyimpl/dummypersistence_test.cpp
+++ b/persistence/src/tests/dummyimpl/dummypersistence_test.cpp
@@ -19,7 +19,7 @@ struct Fixture {
     BucketContent content;
 
     void insert(DocumentId id, Timestamp timestamp, int meta_flags) {
-        content.insert(DocEntry::LP(new DocEntry(timestamp, meta_flags, id)));
+        content.insert(DocEntry::UP(new DocEntry(timestamp, meta_flags, id)));
     }
 
     Fixture() {
@@ -37,14 +37,14 @@ TEST("require that empty BucketContent behaves") {
 }
 
 TEST_F("require that BucketContent can retrieve by timestamp", Fixture) {
-    DocEntry::LP entry = f.content.getEntry(Timestamp(1));
+    DocEntry::SP entry = f.content.getEntry(Timestamp(1));
     ASSERT_TRUE(entry.get());
     ASSERT_TRUE(entry->getDocumentId());
     ASSERT_EQUAL("doc:test:1", entry->getDocumentId()->toString());
 }
 
 TEST_F("require that BucketContent can retrieve by doc id", Fixture) {
-    DocEntry::LP entry = f.content.getEntry(DocumentId("doc:test:2"));
+    DocEntry::SP entry = f.content.getEntry(DocumentId("doc:test:2"));
     ASSERT_TRUE(entry.get());
     ASSERT_TRUE(entry->getDocumentId());
     ASSERT_EQUAL("doc:test:2", entry->getDocumentId()->toString());
diff --git a/persistence/src/tests/proxy/mockprovider.h b/persistence/src/tests/proxy/mockprovider.h
index 42d21d393b8..fa15334625d 100644
--- a/persistence/src/tests/proxy/mockprovider.h
+++ b/persistence/src/tests/proxy/mockprovider.h
@@ -111,8 +111,8 @@ struct MockProvider : PersistenceProvider {
     virtual IterateResult iterate(IteratorId, uint64_t, Context&) const {
         last_called = ITERATE;
         IterateResult::List result;
-        result.push_back(DocEntry::LP(new DocEntry(Timestamp(1), 0)));
-        return IterateResult(result, true);
+        result.push_back(DocEntry::UP(new DocEntry(Timestamp(1), 0)));
+        return IterateResult(std::move(result), true);
     }
 
     virtual Result destroyIterator(IteratorId, Context&) {
diff --git a/persistence/src/vespa/persistence/conformancetest/conformancetest.cpp b/persistence/src/vespa/persistence/conformancetest/conformancetest.cpp
index 861b0afc100..7af0ea68da1 100644
--- a/persistence/src/vespa/persistence/conformancetest/conformancetest.cpp
+++ b/persistence/src/vespa/persistence/conformancetest/conformancetest.cpp
@@ -118,13 +118,13 @@ struct DocAndTimestamp
  */
 struct Chunk
 {
-    std::vector<DocEntry::LP> _entries;
+    std::vector<DocEntry::UP> _entries;
 };
 
 struct DocEntryIndirectTimestampComparator
 {
-    bool operator()(const DocEntry::LP& e1,
-                    const DocEntry::LP& e2) const
+    bool operator()(const DocEntry::UP& e1,
+                    const DocEntry::UP& e2) const
     {
         return e1->getTimestamp() < e2->getTimestamp();
     }
@@ -145,18 +145,12 @@ doIterate(PersistenceProvider& spi,
     std::vector<Chunk> chunks;
 
     while (true) {
-        std::vector<DocEntry::LP> entries;
-
         Context context(defaultLoadType, Priority(0), Trace::TraceLevel(0));
         IterateResult result(spi.iterate(id, maxByteSize, context));
 
         CPPUNIT_ASSERT_EQUAL(Result::NONE, result.getErrorCode());
 
-        for (size_t i = 0; i < result.getEntries().size(); ++i) {
-            entries.push_back(result.getEntries()[i]);
-        }
-        chunks.push_back(Chunk());
-        chunks.back()._entries.swap(entries);
+        chunks.push_back(Chunk{std::move(result.steal_entries())});
         if (result.isCompleted()
             || (maxChunks != 0 && chunks.size() >= maxChunks))
         {
@@ -167,7 +161,7 @@ doIterate(PersistenceProvider& spi,
 }
 
 size_t
-getRemoveEntryCount(const std::vector<spi::DocEntry::LP>& entries)
+getRemoveEntryCount(const std::vector<spi::DocEntry::UP>& entries)
 {
     size_t ret = 0;
     for (size_t i = 0; i < entries.size(); ++i) {
@@ -178,13 +172,13 @@ getRemoveEntryCount(const std::vector<spi::DocEntry::LP>& entries)
     return ret;
 }
 
-std::vector<DocEntry::LP>
+std::vector<DocEntry::UP>
 getEntriesFromChunks(const std::vector<Chunk>& chunks)
 {
-    std::vector<spi::DocEntry::LP> ret;
+    std::vector<spi::DocEntry::UP> ret;
     for (size_t chunk = 0; chunk < chunks.size(); ++chunk) {
         for (size_t i = 0; i < chunks[chunk]._entries.size(); ++i) {
-            ret.push_back(chunks[chunk]._entries[i]);
+            ret.push_back(DocEntry::UP(chunks[chunk]._entries[i]->clone()));
         }
     }
     std::sort(ret.begin(),
@@ -194,12 +188,12 @@ getEntriesFromChunks(const std::vector<Chunk>& chunks)
 }
 
 
-std::vector<DocEntry::LP>
+std::vector<DocEntry::UP>
 iterateBucket(PersistenceProvider& spi,
               const Bucket& bucket,
               IncludedVersions versions)
 {
-    std::vector<DocEntry::LP> ret;
+    std::vector<DocEntry::UP> ret;
     DocumentSelection docSel("");
     Selection sel(docSel);
 
@@ -218,11 +212,10 @@ iterateBucket(PersistenceProvider& spi,
             spi.iterate(iter.getIteratorId(),
                          std::numeric_limits<int64_t>().max(), context);
         if (result.getErrorCode() != Result::NONE) {
-            return std::vector<DocEntry::LP>();
-        }
-        for (size_t i = 0; i < result.getEntries().size(); ++i) {
-            ret.push_back(result.getEntries()[i]);
+            return std::vector<DocEntry::UP>();
         }
+        auto list = result.steal_entries();
+        std::move(list.begin(), list.end(), std::back_inserter(ret));
         if (result.isCompleted()) {
             break;
         }
@@ -240,7 +233,7 @@ verifyDocs(const std::vector<DocAndTimestamp>& wanted,
            const std::vector<Chunk>& chunks,
            const std::set<string>& removes = std::set<string>())
 {
-    std::vector<DocEntry::LP> retrieved(
+    std::vector<DocEntry::UP> retrieved(
             getEntriesFromChunks(chunks));
     size_t removeCount = getRemoveEntryCount(retrieved);
     // Ensure that we've got the correct number of puts and removes
@@ -686,7 +679,7 @@ void ConformanceTest::testPutDuplicate() {
         CPPUNIT_ASSERT_EQUAL(1, (int)info.getDocumentCount());
         CPPUNIT_ASSERT_EQUAL(checksum, info.getChecksum());
     }
-    std::vector<DocEntry::LP> entries(
+    std::vector<DocEntry::UP> entries(
             iterateBucket(*spi, bucket, ALL_VERSIONS));
     CPPUNIT_ASSERT_EQUAL(size_t(1), entries.size());
 }
@@ -711,7 +704,7 @@ void ConformanceTest::testRemove() {
         CPPUNIT_ASSERT_EQUAL(1, (int)info.getDocumentCount());
         CPPUNIT_ASSERT(info.getChecksum() != 0);
 
-        std::vector<DocEntry::LP> entries(
+        std::vector<DocEntry::UP> entries(
                 iterateBucket(*spi, bucket, NEWEST_DOCUMENT_ONLY));
         CPPUNIT_ASSERT_EQUAL(size_t(1), entries.size());
     }
@@ -731,13 +724,13 @@ void ConformanceTest::testRemove() {
         CPPUNIT_ASSERT_EQUAL(true, result2.wasFound());
     }
     {
-        std::vector<DocEntry::LP> entries(iterateBucket(*spi,
+        std::vector<DocEntry::UP> entries(iterateBucket(*spi,
                                                     bucket,
                                                     NEWEST_DOCUMENT_ONLY));
         CPPUNIT_ASSERT_EQUAL(size_t(0), entries.size());
     }
     {
-        std::vector<DocEntry::LP> entries(iterateBucket(*spi,
+        std::vector<DocEntry::UP> entries(iterateBucket(*spi,
                                                     bucket,
                                                     NEWEST_DOCUMENT_OR_REMOVE));
 
@@ -820,7 +813,7 @@ void ConformanceTest::testRemoveMerge() {
 
     // Remove entry should exist afterwards
     {
-        std::vector<DocEntry::LP> entries(iterateBucket(
+        std::vector<DocEntry::UP> entries(iterateBucket(
                 *spi, bucket, ALL_VERSIONS));
         CPPUNIT_ASSERT_EQUAL(size_t(2), entries.size());
         // Timestamp-sorted by iterateBucket
@@ -848,7 +841,7 @@ void ConformanceTest::testRemoveMerge() {
     }
     // Must have new remove. We don't check for the presence of the old remove.
     {
-        std::vector<DocEntry::LP> entries(iterateBucket(*spi, bucket, ALL_VERSIONS));
+        std::vector<DocEntry::UP> entries(iterateBucket(*spi, bucket, ALL_VERSIONS));
         CPPUNIT_ASSERT(entries.size() >= 2);
         CPPUNIT_ASSERT_EQUAL(removeId, *entries.back()->getDocumentId());
         CPPUNIT_ASSERT_EQUAL(Timestamp(11), entries.back()->getTimestamp());
@@ -875,7 +868,7 @@ void ConformanceTest::testRemoveMerge() {
     }
     // Must have newest remove. We don't check for the presence of the old remove.
     {
-        std::vector<DocEntry::LP> entries(iterateBucket(*spi, bucket, ALL_VERSIONS));
+        std::vector<DocEntry::UP> entries(iterateBucket(*spi, bucket, ALL_VERSIONS));
         CPPUNIT_ASSERT(entries.size() >= 2);
         CPPUNIT_ASSERT_EQUAL(removeId, *entries.back()->getDocumentId());
         CPPUNIT_ASSERT_EQUAL(Timestamp(11), entries.back()->getTimestamp());
@@ -1302,7 +1295,7 @@ ConformanceTest::testIterateRemoves()
                 createIterator(*spi, b, sel, NEWEST_DOCUMENT_OR_REMOVE));
 
         std::vector<Chunk> chunks = doIterate(*spi, iter.getIteratorId(), 4096);
-        std::vector<DocEntry::LP> entries = getEntriesFromChunks(chunks);
+        std::vector<DocEntry::UP> entries = getEntriesFromChunks(chunks);
         CPPUNIT_ASSERT_EQUAL(docs.size(), entries.size());
         verifyDocs(nonRemovedDocs, chunks, removedDocs);
 
diff --git a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
index 75c83283c2c..f6a74fea83d 100644
--- a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
+++ b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
@@ -111,8 +111,8 @@ namespace {
 struct HasDocId {
     const DocumentId &_did;
     HasDocId(const DocumentId &did) : _did(did) {}
-    bool operator()(const DocEntry::LP &entry)
-    { return *entry->getDocumentId() == _did; }
+    bool operator()(const DocEntry &entry)
+    { return *entry.getDocumentId() == _did; }
 };
 
 struct TimestampLess {
@@ -159,7 +159,7 @@ BucketContent::hasTimestamp(Timestamp t) const
  */
 
 void
-BucketContent::insert(DocEntry::LP e)
+BucketContent::insert(DocEntry::SP e)
 {
     LOG(spam, "insert(%s)", e->toString().c_str());
     const DocumentId* docId(e->getDocumentId());
@@ -247,24 +247,24 @@ BucketContent::insert(DocEntry::LP e)
     assert(_outdatedInfo || _info.getEntryCount() == _entries.size());
 }
 
-DocEntry::LP
+DocEntry::SP
 BucketContent::getEntry(const DocumentId& did) const
 {
     GidMapType::const_iterator it(_gidMap.find(did.getGlobalId()));
     if (it != _gidMap.end()) {
         return it->second;
     }
-    return DocEntry::LP();
+    return DocEntry::SP();
 }
 
-DocEntry::LP
+DocEntry::SP
 BucketContent::getEntry(Timestamp t) const
 {
     std::vector<BucketEntry>::const_iterator iter =
         lower_bound(_entries.begin(), _entries.end(), t, TimestampLess());
 
     if (iter == _entries.end() || iter->entry->getTimestamp() != t) {
-        return DocEntry::LP();
+        return DocEntry::SP();
     } else {
         return iter->entry;
     }
@@ -435,7 +435,7 @@ DummyPersistence::put(const Bucket& b, Timestamp t, const Document::SP& doc,
         return BucketInfoResult(Result::TRANSIENT_ERROR, "Bucket not found");
     }
 
-    DocEntry::LP existing = (*bc)->getEntry(t);
+    DocEntry::SP existing = (*bc)->getEntry(t);
     if (existing.get()) {
         if (doc->getId() == *existing->getDocumentId()) {
             return Result();
@@ -447,8 +447,8 @@ DummyPersistence::put(const Bucket& b, Timestamp t, const Document::SP& doc,
 
     LOG(spam, "Inserting document %s", doc->toString(true).c_str());
 
-    DocEntry::LP entry(new DocEntry(t, NONE, Document::UP(doc->clone())));
-    (*bc)->insert(entry);
+    DocEntry::UP entry(new DocEntry(t, NONE, Document::UP(doc->clone())));
+    (*bc)->insert(std::move(entry));
     return Result();
 }
 
@@ -490,14 +490,14 @@ DummyPersistence::remove(const Bucket& b,
         return RemoveResult(Result::TRANSIENT_ERROR, "Bucket not found");
     }
 
-    DocEntry::LP entry((*bc)->getEntry(did));
+    DocEntry::SP entry((*bc)->getEntry(did));
     bool foundPut(entry.get() && !entry->isRemove());
-    DocEntry::LP remEntry(new DocEntry(t, REMOVE_ENTRY, did));
+    DocEntry::UP remEntry(new DocEntry(t, REMOVE_ENTRY, did));
 
     if ((*bc)->hasTimestamp(t)) {
         (*bc)->eraseEntry(t);
     }
-    (*bc)->insert(remEntry);
+    (*bc)->insert(std::move(remEntry));
     return RemoveResult(foundPut);
 }
 
@@ -514,7 +514,7 @@ DummyPersistence::get(const Bucket& b,
     BucketContentGuard::UP bc(acquireBucketWithLock(b));
     if (!bc.get()) {
     } else {
-        DocEntry::LP entry((*bc)->getEntry(did));
+        DocEntry::SP entry((*bc)->getEntry(did));
         if (entry.get() == 0 || entry->isRemove()) {
         } else {
             Document::UP doc(entry->getDocument()->clone());
@@ -538,7 +538,7 @@ DummyPersistence::createIterator(
 {
     DUMMYPERSISTENCE_VERIFY_INITIALIZED;
     LOG(debug, "createIterator(%s)", b.toString().c_str());
-    vespalib::LinkedPtr<document::select::Node> docSelection;
+    std::unique_ptr<document::select::Node> docSelection;
     if (!s.getDocumentSelection().getDocumentSelection().empty()) {
         docSelection.reset(
                 parseDocumentSelection(
@@ -563,13 +563,13 @@ DummyPersistence::createIterator(
         ++_nextIterator;
         assert(_iterators.find(id) == _iterators.end());
         it = new Iterator;
-        _iterators[id] = Iterator::LP(it);
+        _iterators[id] = Iterator::UP(it);
         assert(it->_bucket.getBucketId().getRawId() == 0); // Wrap detection
         it->_bucket = b;
     }
     // Memory pointed to by 'it' should now be valid from here on out
 
-    it->_fieldSet = vespalib::LinkedPtr<document::FieldSet>(fs.clone());
+    it->_fieldSet = std::unique_ptr<document::FieldSet>(fs.clone());
     const BucketContent::GidMapType& gidMap((*bc)->_gidMap);
 
     if (s.getTimestampSubset().empty()) {
@@ -630,7 +630,7 @@ DummyPersistence::iterate(IteratorId id, uint64_t maxByteSize, Context& ctx) con
     Iterator* it;
     {
         vespalib::MonitorGuard lock(_monitor);
-        std::map<IteratorId, Iterator::LP>::iterator iter(_iterators.find(id));
+        std::map<IteratorId, Iterator::UP>::iterator iter(_iterators.find(id));
         if (iter == _iterators.end()) {
             return IterateResult(Result::PERMANENT_ERROR,
                         "Bug! Used iterate without sending createIterator first");
@@ -645,12 +645,12 @@ DummyPersistence::iterate(IteratorId id, uint64_t maxByteSize, Context& ctx) con
     }
     LOG(debug, "Iterator %zu acquired bucket lock", uint64_t(id));
 
-    std::vector<DocEntry::LP> entries;
+    std::vector<DocEntry::UP> entries;
     uint32_t currentSize = 0;
     uint32_t fastPath = 0;
     while (!it->_leftToIterate.empty()) {
         Timestamp next(it->_leftToIterate.back());
-        DocEntry::LP entry((*bc)->getEntry(next));
+        DocEntry::SP entry((*bc)->getEntry(next));
         if (entry.get() != 0) {
             uint32_t size = entry->getSize();
             if (currentSize != 0 && currentSize + size > maxByteSize) break;
@@ -664,14 +664,14 @@ DummyPersistence::iterate(IteratorId id, uint64_t maxByteSize, Context& ctx) con
                         document::FieldSet::createDocumentSubsetCopy(
                                 *entry->getDocument(),
                                 *it->_fieldSet));
-                DocEntry::LP ret(new DocEntry(entry->getTimestamp(),
+                DocEntry::UP ret(new DocEntry(entry->getTimestamp(),
                                               entry->getFlags(),
                                               std::move(filtered),
                                               entry->getPersistedDocumentSize()));
-                entries.push_back(ret);
+                entries.push_back(std::move(ret));
             } else {
                 // Use entry as-is.
-                entries.push_back(DocEntry::LP(entry->clone()));
+                entries.push_back(DocEntry::UP(entry->clone()));
                 ++fastPath;
             }
         }
@@ -691,10 +691,10 @@ DummyPersistence::iterate(IteratorId id, uint64_t maxByteSize, Context& ctx) con
         currentSize,
         fastPath);
     if (it->_leftToIterate.empty()) {
-        return IterateResult(entries, true);
+        return IterateResult(std::move(entries), true);
     }
 
-    return IterateResult(entries, false);
+    return IterateResult(std::move(entries), false);
 }
 
 Result
@@ -716,7 +716,7 @@ DummyPersistence::createBucket(const Bucket& b, Context&)
     LOG(debug, "createBucket(%s)", b.toString().c_str());
     vespalib::MonitorGuard lock(_monitor);
     if (_content[b.getPartition()].find(b) == _content[b.getPartition()].end()) {
-        _content[b.getPartition()][b] = BucketContent::LP(new BucketContent);
+        _content[b.getPartition()][b] = BucketContent::SP(new BucketContent);
     } else {
         assert(!_content[b.getPartition()][b]->_inUse);
         LOG(debug, "%s already existed", b.toString().c_str());
@@ -770,16 +770,16 @@ DummyPersistence::split(const Bucket& source,
 
     // Add entries
     for (uint32_t i=0; i<sour._entries.size(); ++i) {
-        DocEntry::LP entry(sour._entries[i].entry);
+        DocEntry::SP entry(sour._entries[i].entry);
 
         document::BucketId bId(
                 target1.getBucketId().getUsedBits(),
                 idFactory.getBucketId(*entry->getDocumentId()).getRawId());
 
         if (bId == target1.getBucketId()) {
-            targ1.insert(entry);
+            targ1.insert(std::move(entry));
         } else {
-            targ2.insert(entry);
+            targ2.insert(std::move(entry));
         }
     }
     targ1.setActive(sour.isActive());
@@ -817,8 +817,8 @@ DummyPersistence::join(const Bucket& source1, const Bucket& source2,
         active |= sour.isActive();
 
         for (uint32_t i=0; i<sour._entries.size(); ++i) {
-            DocEntry::LP entry(sour._entries[i].entry);
-            (*targetGuard)->insert(entry);
+            DocEntry::SP entry(sour._entries[i].entry);
+            (*targetGuard)->insert(std::move(entry));
         }
         sourceGuard.reset(0);
         deleteBucket(source, context);
@@ -842,7 +842,7 @@ DummyPersistence::revert(const Bucket& b, Timestamp t, Context&)
     }
 
     BucketContent& content(**bc);
-    DocEntry::LP docEntry(content.getEntry(t));
+    DocEntry::SP docEntry(content.getEntry(t));
     if (!docEntry.get()) {
         return Result();
     }
@@ -953,4 +953,4 @@ DummyPersistence::releaseBucketNoLock(const BucketContent& bc) const
 } // spi
 } // storage
 
-VESPALIB_HASH_MAP_INSTANTIATE_H(storage::spi::Bucket, vespalib::LinkedPtr<storage::spi::dummy::BucketContent>, document::BucketId::hash)
\ No newline at end of file
+VESPALIB_HASH_MAP_INSTANTIATE_H(storage::spi::Bucket, std::shared_ptr<storage::spi::dummy::BucketContent>, document::BucketId::hash)
diff --git a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
index c1af86d5a77..940e72d1668 100644
--- a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
+++ b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
@@ -28,10 +28,10 @@ namespace dummy {
 
 struct BucketEntry
 {
-    DocEntry::LP entry;
+    DocEntry::SP entry;
     GlobalId gid;
 
-    BucketEntry(const DocEntry::LP& e, const GlobalId& g)
+    BucketEntry(DocEntry::SP e, const GlobalId& g)
         : entry(e),
           gid(g)
     { }
@@ -40,11 +40,11 @@ struct BucketEntry
 struct BucketContent {
     typedef vespalib::hash_map<
         document::GlobalId,
-        DocEntry::LP,
+        DocEntry::SP,
         document::GlobalId::hash
     > GidMapType;
 
-    typedef vespalib::LinkedPtr<BucketContent> LP;
+    using SP = std::shared_ptr<BucketContent>;
 
     std::vector<BucketEntry> _entries;
     GidMapType _gidMap;
@@ -67,9 +67,9 @@ struct BucketContent {
     const BucketInfo& getBucketInfo() const;
     BucketInfo& getMutableBucketInfo() { return _info; }
     bool hasTimestamp(Timestamp) const;
-    void insert(DocEntry::LP);
-    DocEntry::LP getEntry(const DocumentId&) const;
-    DocEntry::LP getEntry(Timestamp) const;
+    void insert(DocEntry::SP);
+    DocEntry::SP getEntry(const DocumentId&) const;
+    DocEntry::SP getEntry(Timestamp) const;
     void eraseEntry(Timestamp t);
     void setActive(bool active = true) {
         _active = active;
@@ -87,10 +87,10 @@ struct BucketContent {
 };
 
 struct Iterator {
-    typedef vespalib::LinkedPtr<Iterator> LP;
+    using UP = std::unique_ptr<Iterator>;
     Bucket _bucket;
     std::vector<Timestamp> _leftToIterate;
-    vespalib::LinkedPtr<document::FieldSet> _fieldSet;
+    std::unique_ptr<document::FieldSet> _fieldSet;
 };
 
 class DummyPersistence;
@@ -220,12 +220,12 @@ private:
     mutable bool _initialized;
     document::DocumentTypeRepo::SP _repo;
     PartitionStateList _partitions;
-    typedef vespalib::hash_map<Bucket, BucketContent::LP, document::BucketId::hash>
+    typedef vespalib::hash_map<Bucket, BucketContent::SP, document::BucketId::hash>
     PartitionContent;
 
     std::vector<PartitionContent> _content;
     IteratorId _nextIterator;
-    mutable std::map<IteratorId, Iterator::LP> _iterators;
+    mutable std::map<IteratorId, Iterator::UP> _iterators;
     vespalib::Monitor _monitor;
 
     std::unique_ptr<ClusterState> _clusterState;
diff --git a/persistence/src/vespa/persistence/proxy/providerproxy.cpp b/persistence/src/vespa/persistence/proxy/providerproxy.cpp
index 72936bbda6c..1f6d0b19be6 100644
--- a/persistence/src/vespa/persistence/proxy/providerproxy.cpp
+++ b/persistence/src/vespa/persistence/proxy/providerproxy.cpp
@@ -198,7 +198,7 @@ IterateResult ProviderProxy::readNoError(const FRT_Values &values) const {
         string doc_id(getString(values[4]._string_array._pt[i]));
         nbostream stream(values[5]._data_array._pt[i]._buf,
                          values[5]._data_array._pt[i]._len);
-        DocEntry::LP entry;
+        DocEntry::UP entry;
         if (!stream.empty()) {
             Document::UP doc = readDocument(stream, *_repo);
             entry.reset(new DocEntry(timestamp, meta_flags, std::move(doc)));
@@ -208,10 +208,10 @@ IterateResult ProviderProxy::readNoError(const FRT_Values &values) const {
         } else {
             entry.reset(new DocEntry(timestamp, meta_flags));
         }
-        result.push_back(entry);
+        result.push_back(std::move(entry));
     }
 
-    return IterateResult(result, values[6]._intval8);
+    return IterateResult(std::move(result), values[6]._intval8);
 }
 
 namespace {
diff --git a/persistence/src/vespa/persistence/proxy/providerstub.cpp b/persistence/src/vespa/persistence/proxy/providerstub.cpp
index 94d4811c0d6..e0f0a22f0dd 100644
--- a/persistence/src/vespa/persistence/proxy/providerstub.cpp
+++ b/persistence/src/vespa/persistence/proxy/providerstub.cpp
@@ -97,7 +97,7 @@ void addIterateResult(FRT_Values &ret, const IterateResult &result)
 {
     addResult(ret, result);
 
-    const vector<DocEntry::LP> &entries = result.getEntries();
+    const vector<DocEntry::UP> &entries = result.getEntries();
     uint64_t *timestamps = ret.AddInt64Array(entries.size());
     uint32_t *flags = ret.AddInt32Array(entries.size());
     assert(sizeof(DocEntry::SizeType) == sizeof(uint32_t));
diff --git a/persistence/src/vespa/persistence/spi/docentry.h b/persistence/src/vespa/persistence/spi/docentry.h
index 69c65465d8e..08db894a89a 100644
--- a/persistence/src/vespa/persistence/spi/docentry.h
+++ b/persistence/src/vespa/persistence/spi/docentry.h
@@ -14,7 +14,6 @@
 #pragma once
 
 #include <persistence/spi/types.h>
-#include <vespa/vespalib/util/linkedptr.h>
 
 namespace storage {
 namespace spi {
@@ -35,8 +34,8 @@ private:
     DocumentIdUP _documentId;
     DocumentUP _document;
 public:
-    typedef vespalib::LinkedPtr<DocEntry> LP;
-    typedef std::unique_ptr<DocEntry> UP;
+    using UP = std::unique_ptr<DocEntry>;
+    using SP = std::shared_ptr<DocEntry>;
 
     DocEntry(Timestamp t, int metaFlags, DocumentUP doc);
 
diff --git a/persistence/src/vespa/persistence/spi/result.h b/persistence/src/vespa/persistence/spi/result.h
index df2a2a55454..ce250f8aabe 100644
--- a/persistence/src/vespa/persistence/spi/result.h
+++ b/persistence/src/vespa/persistence/spi/result.h
@@ -248,7 +248,7 @@ private:
 
 class IterateResult : public Result {
 public:
-    typedef std::vector<DocEntry::LP> List;
+    typedef std::vector<DocEntry::UP> List;
 
     /**
      * Constructor used when there was an error creating the iterator.
@@ -270,15 +270,19 @@ public:
           _entries(std::move(entries))
     { }
 
+    IterateResult(const IterateResult &) = delete;
+    IterateResult(IterateResult &&rhs) = default;
+    IterateResult &operator=(IterateResult &&rhs) = default;
+
     ~IterateResult();
 
     const List& getEntries() const { return _entries; }
-
+    List steal_entries() { return std::move(_entries); }
     bool isCompleted() const { return _completed; }
 
 private:
     bool _completed;
-    std::vector<DocEntry::LP> _entries;
+    std::vector<DocEntry::UP> _entries;
 };
 
 class PartitionStateListResult : public Result