Avoid including everything in document in every file we compile.

26 files changed, 457 insertions, 434 deletions

diff --git a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
index 1bfd92d2b42..11381e5c004 100644
--- a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
+++ b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.cpp
@@ -5,6 +5,8 @@
 #include <algorithm>
 #include <vespa/persistence/dummyimpl/dummypersistence.h>
 #include <vespa/document/select/parser.h>
+#include <vespa/document/base/documentid.h>
+#include <vespa/document/fieldvalue/document.h>
 #include <vespa/vespalib/util/crc.h>
 #include <vespa/vespalib/util/atomic.h>
 #include <vespa/vespalib/util/vstringfmt.h>
@@ -879,10 +881,10 @@ DummyPersistence::dumpBucket(const Bucket& b) const
     if (it == _content[b.getPartition()].end()) {
         return "DOESN'T EXIST";
     } else {
-        std::ostringstream ost;
+        vespalib::asciistream ost;
         for (uint32_t i=0; i<it->second->_entries.size(); ++i) {
             const DocEntry& entry(*it->second->_entries[i].entry);
-            ost << entry << "\n";
+            ost << entry.toString() << "\n";
         }
 
         return ost.str();
diff --git a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
index eca3f2d48cc..6a674182443 100644
--- a/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
+++ b/persistence/src/vespa/persistence/dummyimpl/dummypersistence.h
@@ -10,19 +10,16 @@
 
 #include <vespa/persistence/spi/abstractpersistenceprovider.h>
 #include <vespa/document/repo/documenttyperepo.h>
+#include <vespa/document/base/globalid.h>
 #include <vespa/document/fieldset/fieldsets.h>
 #include <vespa/vespalib/util/sync.h>
 #include <vespa/vespalib/stllike/hash_map.h>
 
 namespace document {
-
-class FieldSet;
-
-namespace select {
-
-class Node;
-
-}
+    class FieldSet;
+    namespace select {
+        class Node;
+    }
 }
 
 namespace storage {
@@ -37,8 +34,7 @@ struct BucketEntry
     BucketEntry(const DocEntry::LP& e, const GlobalId& g)
         : entry(e),
           gid(g)
-    {
-    }
+    { }
 };
 
 struct BucketContent {
@@ -64,8 +60,7 @@ struct BucketContent {
           _inUse(false),
           _outdatedInfo(true),
           _active(false)
-    {
-    }
+    { }
 
     uint32_t computeEntryChecksum(const BucketEntry&) const;
     BucketChecksum updateRollingChecksum(uint32_t entryChecksum);
@@ -160,7 +155,7 @@ public:
 
     BucketInfoResult getBucketInfo(const Bucket&) const;
 
-    Result put(const Bucket&, Timestamp, const Document::SP&, Context&);
+    Result put(const Bucket&, Timestamp, const DocumentSP&, Context&);
     GetResult get(const Bucket&,
                   const document::FieldSet& fieldSet,
                   const DocumentId&,
@@ -242,7 +237,7 @@ private:
 
     bool _simulateMaintainFailure;
 
-    document::select::Node::UP parseDocumentSelection(
+    std::unique_ptr<document::select::Node> parseDocumentSelection(
             const string& documentSelection,
             bool allowLeaf);
 
diff --git a/persistence/src/vespa/persistence/proxy/providerproxy.cpp b/persistence/src/vespa/persistence/proxy/providerproxy.cpp
index 8c37a4da5ca..7c3b5250c8c 100644
--- a/persistence/src/vespa/persistence/proxy/providerproxy.cpp
+++ b/persistence/src/vespa/persistence/proxy/providerproxy.cpp
@@ -1,18 +1,20 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
-LOG_SETUP(".providerproxy");
-
-#include "buildid.h"
 #include "providerproxy.h"
+#include "buildid.h"
 #include <vespa/document/repo/documenttyperepo.h>
+#include <vespa/document/update/documentupdate.h>
+#include <vespa/document/fieldvalue/document.h>
 #include <vespa/document/fieldset/fieldsetrepo.h>
 #include <vespa/document/serialization/vespadocumentdeserializer.h>
 #include <vespa/document/serialization/vespadocumentserializer.h>
 #include <vespa/document/util/bytebuffer.h>
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/util/noncopyable.hpp>
+#include <vespa/fnet/frt/frt.h>
+#include <vespa/log/log.h>
+LOG_SETUP(".providerproxy");
 
 using document::BucketId;
 using document::ByteBuffer;
@@ -224,13 +226,13 @@ bool shouldFailFast(uint32_t error_code) {
 
 ProviderProxy::ProviderProxy(const vespalib::string &connect_spec,
                              const DocumentTypeRepo &repo)
-    : _supervisor(),
+    : _supervisor(new FRT_Supervisor()),
       _target(0),
       _repo(&repo)
 {
-    _supervisor.Start();
+    _supervisor->Start();
     bool connected = false;
-    _target = _supervisor.GetTarget(connect_spec.c_str());
+    _target = _supervisor->GetTarget(connect_spec.c_str());
     for (size_t i = 0; !connected && (i < (100 + 300)); ++i) {
         FRT_RPCRequest *req = new FRT_RPCRequest();
         req->SetMethodName("vespa.persistence.connect");
@@ -250,7 +252,7 @@ ProviderProxy::ProviderProxy(const vespalib::string &connect_spec,
             } else {
                 FastOS_Thread::Sleep(1000); // retry each 1s for 5m
             }
-            _target = _supervisor.GetTarget(connect_spec.c_str());
+            _target = _supervisor->GetTarget(connect_spec.c_str());
         }
     }
     if (!connected) {
@@ -260,23 +262,23 @@ ProviderProxy::ProviderProxy(const vespalib::string &connect_spec,
 
 ProviderProxy::~ProviderProxy() {
     _target->SubRef();
-    _supervisor.ShutDown(true);
+    _supervisor->ShutDown(true);
 }
 
 Result ProviderProxy::initialize() {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.initialize");
     return invokeRpc_Return<Result>(*req, "bs");
 }
 
 PartitionStateListResult ProviderProxy::getPartitionStates() const {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.getPartitionStates");
     return invokeRpc_Return<PartitionStateListResult>(*req, "bsIS");
 }
 
 BucketIdListResult ProviderProxy::listBuckets(PartitionId partition) const {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.listBuckets");
     req->GetParams()->AddInt64(partition);
 
@@ -284,7 +286,7 @@ BucketIdListResult ProviderProxy::listBuckets(PartitionId partition) const {
 }
 
 Result ProviderProxy::setClusterState(const ClusterState& clusterState) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.setClusterState");
 
     vespalib::nbostream o;
@@ -295,7 +297,7 @@ Result ProviderProxy::setClusterState(const ClusterState& clusterState) {
 
 Result ProviderProxy::setActiveState(const Bucket &bucket,
                                      BucketInfo::ActiveState newState) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.setActiveState");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt8(newState);
@@ -303,7 +305,7 @@ Result ProviderProxy::setActiveState(const Bucket &bucket,
 }
 
 BucketInfoResult ProviderProxy::getBucketInfo(const Bucket &bucket) const {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.getBucketInfo");
     addBucket(*req->GetParams(), bucket);
     return invokeRpc_Return<BucketInfoResult>(*req, "bsiiiiibb");
@@ -312,7 +314,7 @@ BucketInfoResult ProviderProxy::getBucketInfo(const Bucket &bucket) const {
 Result ProviderProxy::put(const Bucket &bucket, Timestamp timestamp,
                           const Document::SP& doc, Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.put");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt64(timestamp);
@@ -325,7 +327,7 @@ RemoveResult ProviderProxy::remove(const Bucket &bucket,
                                    const DocumentId &id,
                                    Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.removeById");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt64(timestamp);
@@ -338,7 +340,7 @@ RemoveResult ProviderProxy::removeIfFound(const Bucket &bucket,
                                           const DocumentId &id,
                                           Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.removeIfFound");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt64(timestamp);
@@ -350,7 +352,7 @@ UpdateResult ProviderProxy::update(const Bucket &bucket, Timestamp timestamp,
                                    const DocumentUpdate::SP& doc_update,
                                    Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.update");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt64(timestamp);
@@ -359,7 +361,7 @@ UpdateResult ProviderProxy::update(const Bucket &bucket, Timestamp timestamp,
 }
 
 Result ProviderProxy::flush(const Bucket &bucket, Context&) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.flush");
     addBucket(*req->GetParams(), bucket);
     return invokeRpc_Return<Result>(*req, "bs");
@@ -370,7 +372,7 @@ GetResult ProviderProxy::get(const Bucket &bucket,
                              const DocumentId &doc_id,
                              Context&) const
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.get");
     document::FieldSetRepo repo;
     addBucket(*req->GetParams(), bucket);
@@ -385,7 +387,7 @@ CreateIteratorResult ProviderProxy::createIterator(const Bucket &bucket,
                                                    IncludedVersions versions,
                                                    Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.createIterator");
     addBucket(*req->GetParams(), bucket);
 
@@ -400,7 +402,7 @@ IterateResult ProviderProxy::iterate(IteratorId id,
                                      uint64_t max_byte_size,
                                      Context&) const
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.iterate");
     req->GetParams()->AddInt64(id);
     req->GetParams()->AddInt64(max_byte_size);
@@ -408,28 +410,28 @@ IterateResult ProviderProxy::iterate(IteratorId id,
 }
 
 Result ProviderProxy::destroyIterator(IteratorId id, Context&) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.destroyIterator");
     req->GetParams()->AddInt64(id);
     return invokeRpc_Return<Result>(*req, "bs");
 }
 
 Result ProviderProxy::createBucket(const Bucket &bucket, Context&) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.createBucket");
     addBucket(*req->GetParams(), bucket);
     return invokeRpc_Return<Result>(*req, "bs");
 }
 
 Result ProviderProxy::deleteBucket(const Bucket &bucket, Context&) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.deleteBucket");
     addBucket(*req->GetParams(), bucket);
     return invokeRpc_Return<Result>(*req, "bs");
 }
 
 BucketIdListResult ProviderProxy::getModifiedBuckets() const {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.getModifiedBuckets");
     return invokeRpc_Return<BucketIdListResult>(*req, "bsL");
 }
@@ -439,7 +441,7 @@ Result ProviderProxy::split(const Bucket &source,
                             const Bucket &target2,
                             Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.split");
     addBucket(*req->GetParams(), source);
     addBucket(*req->GetParams(), target1);
@@ -452,7 +454,7 @@ Result ProviderProxy::join(const Bucket &source1,
                            const Bucket &target,
                            Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.join");
     addBucket(*req->GetParams(), source1);
     addBucket(*req->GetParams(), source2);
@@ -464,7 +466,7 @@ Result ProviderProxy::move(const Bucket &source,
                            PartitionId target,
                            Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.move");
     addBucket(*req->GetParams(), source);
     req->GetParams()->AddInt64(target);
@@ -472,7 +474,7 @@ Result ProviderProxy::move(const Bucket &source,
 }
 
 Result ProviderProxy::maintain(const Bucket &bucket, MaintenanceLevel level) {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.maintain");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt8(level);
@@ -482,7 +484,7 @@ Result ProviderProxy::maintain(const Bucket &bucket, MaintenanceLevel level) {
 Result ProviderProxy::removeEntry(const Bucket &bucket, Timestamp timestamp,
                                   Context&)
 {
-    RequestScopedPtr req(_supervisor.AllocRPCRequest());
+    RequestScopedPtr req(_supervisor->AllocRPCRequest());
     req->SetMethodName("vespa.persistence.removeEntry");
     addBucket(*req->GetParams(), bucket);
     req->GetParams()->AddInt64(timestamp);
diff --git a/persistence/src/vespa/persistence/proxy/providerproxy.h b/persistence/src/vespa/persistence/proxy/providerproxy.h
index 389fb0a3857..4dd995120d5 100644
--- a/persistence/src/vespa/persistence/proxy/providerproxy.h
+++ b/persistence/src/vespa/persistence/proxy/providerproxy.h
@@ -2,20 +2,27 @@
 
 #pragma once
 
-#include <vespa/fnet/frt/frt.h>
 #include <vespa/persistence/spi/persistenceprovider.h>
 
+class FRT_Target;
+class FRT_Supervisor;
+class FRT_RPCRequest;
+class FRT_Values;
+
+namespace document {
+    class DocumentTypeRepo;
+}
+
 namespace storage {
 namespace spi {
 
 class ProviderProxy : public PersistenceProvider {
-    mutable FRT_Supervisor _supervisor;
+    std::unique_ptr<FRT_Supervisor> _supervisor;
     FRT_Target *_target;
     const document::DocumentTypeRepo *_repo;
 
     template <typename ResultType>
-    ResultType invokeRpc_Return(FRT_RPCRequest &req,
-                                const char *res_spec) const;
+    ResultType invokeRpc_Return(FRT_RPCRequest &req, const char *res_spec) const;
     template <typename ResultType>
     ResultType readResult(const FRT_Values &values) const;
     template <typename ResultType>
@@ -24,65 +31,44 @@ class ProviderProxy : public PersistenceProvider {
 public:
     typedef std::unique_ptr<ProviderProxy> UP;
 
-    ProviderProxy(const vespalib::string &connect_spec,
-                  const document::DocumentTypeRepo &repo);
+    ProviderProxy(const vespalib::string &connect_spec, const document::DocumentTypeRepo &repo);
     ~ProviderProxy();
 
     void setRepo(const document::DocumentTypeRepo &repo) {
         _repo = &repo;
     }
 
-    virtual Result initialize();
-    virtual PartitionStateListResult getPartitionStates() const;
-    virtual BucketIdListResult listBuckets(PartitionId) const;
-    virtual Result setClusterState(const ClusterState&);
-    virtual Result setActiveState(const Bucket&, BucketInfo::ActiveState);
-    virtual BucketInfoResult getBucketInfo(const Bucket &) const;
-
-    virtual Result put(const Bucket &, Timestamp, const Document::SP&, Context&);
-    virtual RemoveResult remove(const Bucket &, Timestamp, const DocumentId &,
-                                Context&);
-    virtual RemoveResult removeIfFound(const Bucket &, Timestamp,
-                                       const DocumentId &, Context&);
-    virtual UpdateResult update(const Bucket &, Timestamp,
-                                const DocumentUpdate::SP&, Context&);
-
-    virtual Result flush(const Bucket &, Context&);
-
-    virtual GetResult get(const Bucket &,
-                          const document::FieldSet&,
-                          const DocumentId &,
-                          Context&) const;
-
-    virtual CreateIteratorResult createIterator(const Bucket &,
-                                                const document::FieldSet&,
-                                                const Selection&,
-                                                IncludedVersions versions,
-                                                Context&);
-
-    virtual IterateResult iterate(IteratorId, uint64_t max_byte_size,
-                                  Context&) const;
-    virtual Result destroyIterator(IteratorId, Context&);
-
-    virtual Result createBucket(const Bucket &, Context&);
-    virtual Result deleteBucket(const Bucket &, Context&);
-    virtual BucketIdListResult getModifiedBuckets() const;
-    virtual Result split(const Bucket &source,
-                         const Bucket &target1,
-                         const Bucket &target2,
-                         Context&);
-
-    virtual Result join(const Bucket &source1,
-                        const Bucket &source2,
-                        const Bucket &target,
-                        Context&);
-
-    virtual Result move(const Bucket &source,
-                        PartitionId partition,
-                        Context&);
-
-    virtual Result maintain(const Bucket &, MaintenanceLevel);
-    virtual Result removeEntry(const Bucket &, Timestamp, Context&);
+    Result initialize() override;
+    PartitionStateListResult getPartitionStates() const override;
+    BucketIdListResult listBuckets(PartitionId) const override;
+    Result setClusterState(const ClusterState&) override;
+    Result setActiveState(const Bucket&, BucketInfo::ActiveState) override;
+    BucketInfoResult getBucketInfo(const Bucket &) const override;
+
+    Result put(const Bucket &, Timestamp, const DocumentSP&, Context&) override;
+    RemoveResult remove(const Bucket &, Timestamp, const DocumentId &, Context&) override;
+    RemoveResult removeIfFound(const Bucket &, Timestamp, const DocumentId &, Context&) override;
+    UpdateResult update(const Bucket &, Timestamp, const DocumentUpdateSP&, Context&) override;
+
+    Result flush(const Bucket &, Context&) override;
+
+    GetResult get(const Bucket &, const document::FieldSet&, const DocumentId &, Context&) const override;
+
+    CreateIteratorResult createIterator(const Bucket &, const document::FieldSet&, const Selection&,
+                                                IncludedVersions versions, Context&) override;
+
+    IterateResult iterate(IteratorId, uint64_t max_byte_size, Context&) const override;
+    Result destroyIterator(IteratorId, Context&) override;
+
+    Result createBucket(const Bucket &, Context&) override;
+    Result deleteBucket(const Bucket &, Context&) override;
+    BucketIdListResult getModifiedBuckets() const override;
+    Result split(const Bucket &source, const Bucket &target1, const Bucket &target2, Context&) override;
+    Result join(const Bucket &source1, const Bucket &source2, const Bucket &target, Context&) override;
+    Result move(const Bucket &source, PartitionId partition, Context&) override;
+
+    Result maintain(const Bucket &, MaintenanceLevel) override;
+    Result removeEntry(const Bucket &, Timestamp, Context&) override;
 };
 
 }  // namespace spi
diff --git a/persistence/src/vespa/persistence/proxy/providerstub.cpp b/persistence/src/vespa/persistence/proxy/providerstub.cpp
index 6f2d565a5f2..f7c73ae009a 100644
--- a/persistence/src/vespa/persistence/proxy/providerstub.cpp
+++ b/persistence/src/vespa/persistence/proxy/providerstub.cpp
@@ -1,20 +1,22 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
-LOG_SETUP(".providerstub");
-
 #include "buildid.h"
 #include "providerstub.h"
 #include <vespa/document/serialization/vespadocumentdeserializer.h>
 #include <vespa/document/serialization/vespadocumentserializer.h>
 #include <vespa/document/util/bytebuffer.h>
+#include <vespa/document/base/documentid.h>
+#include <vespa/document/update/documentupdate.h>
+#include <vespa/document/fieldvalue/document.h>
 #include <vespa/persistence/spi/persistenceprovider.h>
 #include <persistence/spi/types.h>
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/util/closuretask.h>
 #include <sstream>
 #include <vespa/document/fieldset/fieldsetrepo.h>
+#include <vespa/log/log.h>
+LOG_SETUP(".providerstub");
 
 using document::BucketId;
 using document::ByteBuffer;
diff --git a/persistence/src/vespa/persistence/spi/CMakeLists.txt b/persistence/src/vespa/persistence/spi/CMakeLists.txt
index 17cf823279b..dd0478c0c6a 100644
--- a/persistence/src/vespa/persistence/spi/CMakeLists.txt
+++ b/persistence/src/vespa/persistence/spi/CMakeLists.txt
@@ -11,5 +11,7 @@ vespa_add_library(persistence_spi OBJECT
     context.cpp
     metricpersistenceprovider.cpp
     read_consistency.cpp
+    result
+    docentry
     DEPENDS
 )
diff --git a/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.cpp b/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.cpp
index 31e7975a040..083af32672d 100644
--- a/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.cpp
+++ b/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.cpp
@@ -1,6 +1,6 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/fastos/fastos.h>
-#include <vespa/persistence/spi/abstractpersistenceprovider.h>
+#include "abstractpersistenceprovider.h"
 #include <vespa/document/update/documentupdate.h>
 #include <vespa/document/fieldset/fieldsets.h>
 
@@ -10,18 +10,13 @@ namespace storage {
 namespace spi {
 
 UpdateResult
-AbstractPersistenceProvider::update(const Bucket& bucket,
-                                    Timestamp ts,
-                                    const DocumentUpdate::SP& upd,
-                                    Context& context)
+AbstractPersistenceProvider::update(const Bucket& bucket, Timestamp ts,
+                                    const DocumentUpdate::SP& upd, Context& context)
 {
-    GetResult getResult = get(bucket,
-                              document::AllFields(),
-                              upd->getId(), context);
+    GetResult getResult = get(bucket, document::AllFields(), upd->getId(), context);
 
     if (getResult.hasError()) {
-        return UpdateResult(getResult.getErrorCode(),
-                            getResult.getErrorMessage());
+        return UpdateResult(getResult.getErrorCode(), getResult.getErrorMessage());
     }
 
     if (!getResult.hasDocument()) {
@@ -30,10 +25,7 @@ AbstractPersistenceProvider::update(const Bucket& bucket,
 
     upd->applyTo(getResult.getDocument());
 
-    Result putResult = put(bucket,
-                           ts,
-                           getResult.getDocumentPtr(),
-                           context);
+    Result putResult = put(bucket, ts, getResult.getDocumentPtr(), context);
 
     if (putResult.hasError()) {
         return UpdateResult(putResult.getErrorCode(),
@@ -44,10 +36,8 @@ AbstractPersistenceProvider::update(const Bucket& bucket,
 }
 
 RemoveResult
-AbstractPersistenceProvider::removeIfFound(const Bucket& b,
-                                           Timestamp timestamp,
-                                           const DocumentId& id,
-                                           Context& context)
+AbstractPersistenceProvider::removeIfFound(const Bucket& b, Timestamp timestamp,
+                                           const DocumentId& id, Context& context)
 {
     return remove(b, timestamp, id, context);
 }
@@ -60,9 +50,7 @@ AbstractPersistenceProvider::getModifiedBuckets() const
 }
 
 Result
-AbstractPersistenceProvider::move(const Bucket& source,
-                                  PartitionId target,
-                                  Context& context)
+AbstractPersistenceProvider::move(const Bucket& source, PartitionId target, Context& context)
 {
     spi::Bucket to(source.getBucketId(), spi::PartitionId(target));
 
@@ -72,6 +60,3 @@ AbstractPersistenceProvider::move(const Bucket& source,
 }
 
 }
-
-
-
diff --git a/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.h b/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.h
index f06d20860ad..fe8028913a4 100644
--- a/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.h
+++ b/persistence/src/vespa/persistence/spi/abstractpersistenceprovider.h
@@ -19,69 +19,57 @@ public:
     /**
      * Default impl is empty.
      */
-    virtual Result initialize() { return Result(); };
+    Result initialize() override { return Result(); };
 
     /**
      * Updates the document by calling get(), updating the document,
      * then calling put() on the result.
      */
-    virtual UpdateResult update(const Bucket&,
-                                Timestamp,
-                                const DocumentUpdate::SP&,
-                                Context&);
+    UpdateResult update(const Bucket&, Timestamp, const DocumentUpdateSP&, Context&) override;
 
     /**
      * Default impl empty.
      */
-    virtual Result createBucket(const Bucket&, Context&) { return Result(); }
+    Result createBucket(const Bucket&, Context&) override { return Result(); }
 
     /**
      * Default impl is empty.
      */
-    virtual Result maintain(const Bucket&,
-                            MaintenanceLevel) { return Result(); }
+    Result maintain(const Bucket&, MaintenanceLevel) override { return Result(); }
 
     /**
      * Default impl is empty.
      */
-    virtual Result removeEntry(const Bucket&,
-                               Timestamp, Context&) { return Result(); }
+    Result removeEntry(const Bucket&, Timestamp, Context&) override { return Result(); }
 
     /**
      * Default impl is getBucketInfo();
      */
-    virtual Result flush(const Bucket&, Context&) { return Result(); }
+    Result flush(const Bucket&, Context&) override { return Result(); }
 
     /**
      * Default impl is remove().
      */
-    virtual RemoveResult removeIfFound(const Bucket&,
-                                       Timestamp,
-                                       const DocumentId&,
-                                       Context&);
+    RemoveResult removeIfFound(const Bucket&, Timestamp, const DocumentId&, Context&) override;
 
     /**
      * Default impl empty.
      */
-    virtual Result setClusterState(const ClusterState&)
-    { return Result(); }
+    Result setClusterState(const ClusterState&) override { return Result(); }
 
     /**
      * Default impl empty.
      */
-    virtual Result setActiveState(const Bucket&,
-                                  BucketInfo::ActiveState)
-    { return Result(); }
-
+    Result setActiveState(const Bucket&, BucketInfo::ActiveState) override { return Result(); } 
     /**
      * Default impl empty.
      */
-    virtual BucketIdListResult getModifiedBuckets() const;
+    BucketIdListResult getModifiedBuckets() const override;
 
     /**
      * Uses join by default.
      */
-    virtual Result move(const Bucket& source, PartitionId id, Context&);
+    Result move(const Bucket& source, PartitionId id, Context&) override;
 };
 
 }
diff --git a/persistence/src/vespa/persistence/spi/bucket.cpp b/persistence/src/vespa/persistence/spi/bucket.cpp
index 12644a5cfb5..5221cf7a283 100644
--- a/persistence/src/vespa/persistence/spi/bucket.cpp
+++ b/persistence/src/vespa/persistence/spi/bucket.cpp
@@ -1,8 +1,7 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/fastos/fastos.h>
 #include <vespa/persistence/spi/bucket.h>
-#include <sstream>
-#include <iomanip>
+#include <ostream>
 
 namespace storage {
 namespace spi {
diff --git a/persistence/src/vespa/persistence/spi/bucket.h b/persistence/src/vespa/persistence/spi/bucket.h
index b969f6363bf..44e3a9b66b8 100644
--- a/persistence/src/vespa/persistence/spi/bucket.h
+++ b/persistence/src/vespa/persistence/spi/bucket.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include <persistence/spi/types.h>
+#include <vespa/document/bucket/bucketid.h>
 
 namespace storage {
 namespace spi {
diff --git a/persistence/src/vespa/persistence/spi/bucketinfo.cpp b/persistence/src/vespa/persistence/spi/bucketinfo.cpp
index 3b298cfc2b2..2a535b79636 100644
--- a/persistence/src/vespa/persistence/spi/bucketinfo.cpp
+++ b/persistence/src/vespa/persistence/spi/bucketinfo.cpp
@@ -50,7 +50,7 @@ vespalib::string
 BucketInfo::toString() const {
     vespalib::asciistream out;
     out << "BucketInfo(";
-    out << "crc 0x" << std::hex << _checksum << std::dec
+    out << "crc 0x" << vespalib::hex << _checksum << vespalib::dec
         << ", documentCount " << _documentCount;
     if (_documentSize != 0) {
         out << ", documentSize " << _documentSize;
diff --git a/persistence/src/vespa/persistence/spi/bucketinfo.h b/persistence/src/vespa/persistence/spi/bucketinfo.h
index b4019c3c6cf..d5d2440820a 100644
--- a/persistence/src/vespa/persistence/spi/bucketinfo.h
+++ b/persistence/src/vespa/persistence/spi/bucketinfo.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <persistence/spi/types.h>
+#include <vespa/vespalib/stllike/asciistream.h>
 
 namespace storage {
 namespace spi {
@@ -35,7 +36,6 @@ public:
                ActiveState active = NOT_ACTIVE);
 
     bool operator==(const BucketInfo& o) const;
-    void print(std::ostream& out) const;
 
     vespalib::string toString() const;
 
diff --git a/persistence/src/vespa/persistence/spi/clusterstate.cpp b/persistence/src/vespa/persistence/spi/clusterstate.cpp
index 26897a79bc1..4c1d2606a9a 100644
--- a/persistence/src/vespa/persistence/spi/clusterstate.cpp
+++ b/persistence/src/vespa/persistence/spi/clusterstate.cpp
@@ -1,6 +1,8 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/fastos/fastos.h>
 #include <vespa/persistence/spi/clusterstate.h>
+#include <vespa/vdslib/state/clusterstate.h>
+#include <vespa/vdslib/distribution/distribution.h>
 
 namespace storage {
 namespace spi {
@@ -41,6 +43,8 @@ ClusterState::ClusterState(const ClusterState& other)
     deserialize(o);
 }
 
+ClusterState::~ClusterState() { }
+
 ClusterState&
 ClusterState::operator=(const ClusterState& other)
 {
diff --git a/persistence/src/vespa/persistence/spi/clusterstate.h b/persistence/src/vespa/persistence/spi/clusterstate.h
index 5d29c7ce122..52a71c561dd 100644
--- a/persistence/src/vespa/persistence/spi/clusterstate.h
+++ b/persistence/src/vespa/persistence/spi/clusterstate.h
@@ -1,12 +1,15 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #pragma once
 
-#include <vespa/persistence/spi/bucket.h>
-#include <vespa/vdslib/state/clusterstate.h>
-#include <vespa/vdslib/distribution/distribution.h>
+#include "bucket.h"
 
 namespace storage {
 
+namespace lib {
+    class ClusterState;
+    class Distribution;
+}
+
 namespace spi {
 
 /**
@@ -24,6 +27,7 @@ public:
 
     ClusterState(const ClusterState& other);
     ClusterState& operator=(const ClusterState& other);
+    ~ClusterState();
 
     /**
      * Returns true if the system has been set up to have
diff --git a/persistence/src/vespa/persistence/spi/context.h b/persistence/src/vespa/persistence/spi/context.h
index e25338552e2..6758355515f 100644
--- a/persistence/src/vespa/persistence/spi/context.h
+++ b/persistence/src/vespa/persistence/spi/context.h
@@ -32,15 +32,16 @@
 #include <vespa/metrics/loadmetric.h>
 #include <persistence/spi/types.h>
 #include <vespa/persistence/spi/read_consistency.h>
-#include <vector>
-#include <vespa/vespalib/stllike/string.h>
 #include <vespa/vespalib/trace/trace.h>
-#include <vespa/vespalib/util/linkedptr.h>
+
+namespace metrics {
+    class LoadType;
+}
 
 namespace storage {
 namespace spi {
 
-typedef metrics::LoadType LoadType;
+using LoadType = metrics::LoadType;
 
 typedef uint16_t Priority; // 0 - max pri, 255 - min pri
 
@@ -61,13 +62,14 @@ public:
           _priority(pri),
           _trace(maxTraceLevel),
           _readConsistency(ReadConsistency::STRONG)
-    {}
+    { }
 
     const LoadType& getLoadType() const { return *_loadType; }
     Priority getPriority() const { return _priority; }
     int getMaxTraceLevel() const { return _trace.getLevel(); }
-    void addTrace(const vespalib::TraceNode& traceNode)
-        { _trace.getRoot().addChild(traceNode); }
+    void addTrace(const vespalib::TraceNode& traceNode) {
+        _trace.getRoot().addChild(traceNode);
+    }
 
     /**
      * A read operation might choose to relax its consistency requirements,
diff --git a/persistence/src/vespa/persistence/spi/docentry.cpp b/persistence/src/vespa/persistence/spi/docentry.cpp
new file mode 100644
index 00000000000..542c773f6aa
--- /dev/null
+++ b/persistence/src/vespa/persistence/spi/docentry.cpp
@@ -0,0 +1,170 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "docentry.h"
+#include <vespa/document/fieldvalue/document.h>
+#include <vespa/document/base/documentid.h>
+#include <sstream>
+
+namespace storage {
+namespace spi {
+
+DocEntry::DocEntry(Timestamp t, int metaFlags, DocumentUP doc)
+    : _timestamp(t),
+      _metaFlags(metaFlags),
+      _persistedDocumentSize(doc->getSerializedSize()),
+      _size(_persistedDocumentSize + sizeof(DocEntry)),
+      _documentId(),
+      _document(std::move(doc))
+{ }
+
+DocEntry::DocEntry(Timestamp t,
+         int metaFlags,
+         DocumentUP doc,
+         size_t serializedDocumentSize)
+    : _timestamp(t),
+      _metaFlags(metaFlags),
+      _persistedDocumentSize(serializedDocumentSize),
+      _size(_persistedDocumentSize + sizeof(DocEntry)),
+      _documentId(),
+      _document(std::move(doc))
+{ }
+
+DocEntry::DocEntry(Timestamp t, int metaFlags, const DocumentId& docId)
+    : _timestamp(t),
+      _metaFlags(metaFlags),
+      _persistedDocumentSize(docId.getSerializedSize()),
+      _size(_persistedDocumentSize + sizeof(DocEntry)),
+      _documentId(new DocumentId(docId)),
+      _document()
+{ }
+
+DocEntry::DocEntry(Timestamp t, int metaFlags)
+    : _timestamp(t),
+      _metaFlags(metaFlags),
+      _persistedDocumentSize(0),
+      _size(sizeof(DocEntry)),
+      _documentId(),
+      _document()
+{ }
+
+DocEntry::~DocEntry() { }
+
+DocEntry* 
+DocEntry::clone() const {
+    DocEntry* ret;
+    if (_documentId.get() != 0) {
+        ret = new DocEntry(_timestamp, _metaFlags, *_documentId);
+        ret->setPersistedDocumentSize(_persistedDocumentSize);
+    } else if (_document.get()) {
+        ret = new DocEntry(_timestamp, _metaFlags,
+                           DocumentUP(new Document(*_document)),
+                           _persistedDocumentSize);
+    } else {
+        ret = new DocEntry(_timestamp, _metaFlags);
+        ret->setPersistedDocumentSize(_persistedDocumentSize);
+    }
+    return ret;
+}
+
+const DocumentId*
+DocEntry::getDocumentId() const {
+    return (_document.get() != 0 ? &_document->getId()
+                                 : _documentId.get());
+}
+
+DocumentUP
+DocEntry::releaseDocument() {
+    return std::move(_document);
+}
+
+DocEntry::SizeType
+DocEntry::getDocumentSize() const
+{
+    assert(_size >= sizeof(DocEntry));
+    return _size - sizeof(DocEntry);
+}
+
+vespalib::string
+DocEntry::toString() const
+{
+    std::ostringstream out;
+    out << "DocEntry(" << _timestamp << ", " << _metaFlags << ", ";
+    if (_documentId.get() != 0) {
+        out << *_documentId;
+    } else if (_document.get()) {
+        out << "Doc(" << _document->getId() << ")";
+    } else {
+        out << "metadata only";
+    }
+    out << ")";
+    return out.str();
+}
+
+void
+DocEntry::prettyPrint(std::ostream& out) const
+{
+    std::string flags;
+    if (_metaFlags == REMOVE_ENTRY) {
+        flags = " (remove)";
+    }
+
+    out << "DocEntry(Timestamp: " << _timestamp
+        << ", size " << getPersistedDocumentSize() << ", ";
+    if (_documentId.get() != 0) {
+        out << *_documentId;
+    } else if (_document.get()) {
+        out << "Doc(" << _document->getId() << ")";
+    } else {
+        out << "metadata only";
+    }
+    out << flags << ")";
+}
+
+bool
+DocEntry::operator==(const DocEntry& entry) const {
+    if (_timestamp != entry._timestamp) {
+        return false;
+    }
+
+    if (_metaFlags != entry._metaFlags) {
+        return false;
+    }
+
+    if (_documentId.get()) {
+        if (!entry._documentId.get()) {
+            return false;
+        }
+
+        if (*_documentId != *entry._documentId) {
+            return false;
+        }
+    } else {
+        if (entry._documentId.get()) {
+            return false;
+        }
+    }
+
+    if (_document.get()) {
+        if (!entry._document.get()) {
+            return false;
+        }
+
+        if (*_document != *entry._document) {
+            return false;
+        }
+    } else {
+        if (entry._document.get()) {
+            return false;
+        }
+    }
+    if (_persistedDocumentSize != entry._persistedDocumentSize) {
+        return false;
+    }
+
+    return true;
+}
+
+} // spi
+} // storage
+
+
diff --git a/persistence/src/vespa/persistence/spi/docentry.h b/persistence/src/vespa/persistence/spi/docentry.h
index 78db866d70e..1648a56a522 100644
--- a/persistence/src/vespa/persistence/spi/docentry.h
+++ b/persistence/src/vespa/persistence/spi/docentry.h
@@ -14,6 +14,7 @@
 #pragma once
 
 #include <persistence/spi/types.h>
+#include <vespa/vespalib/util/linkedptr.h>
 
 namespace storage {
 namespace spi {
@@ -23,7 +24,7 @@ enum DocumentMetaFlags {
     REMOVE_ENTRY     = 0x1
 };
 
-class DocEntry : public document::Printable {
+class DocEntry {
 public:
     typedef uint32_t SizeType;
 private:
@@ -31,85 +32,30 @@ private:
     int _metaFlags;
     SizeType _persistedDocumentSize;
     SizeType _size;
-    DocumentId::UP _documentId;
-    Document::UP _document;
+    DocumentIdUP _documentId;
+    DocumentUP _document;
 public:
     typedef vespalib::LinkedPtr<DocEntry> LP;
     typedef std::unique_ptr<DocEntry> UP;
 
-    DocEntry(Timestamp t, int metaFlags, Document::UP doc)
-        : _timestamp(t),
-          _metaFlags(metaFlags),
-          _persistedDocumentSize(doc->getSerializedSize()),
-          _size(_persistedDocumentSize + sizeof(DocEntry)),
-          _documentId(),
-          _document(std::move(doc))
-    {
-    }
+    DocEntry(Timestamp t, int metaFlags, DocumentUP doc);
 
     /**
      * Constructor that can be used by providers that already know
      * the serialized size of the document, so the potentially expensive
      * call to getSerializedSize can be avoided.
      */
-    DocEntry(Timestamp t,
-             int metaFlags,
-             Document::UP doc,
-             size_t serializedDocumentSize)
-        : _timestamp(t),
-          _metaFlags(metaFlags),
-          _persistedDocumentSize(serializedDocumentSize),
-          _size(_persistedDocumentSize + sizeof(DocEntry)),
-          _documentId(),
-          _document(std::move(doc))
-    {
-    }
-
-    DocEntry(Timestamp t, int metaFlags, const DocumentId& docId)
-        : _timestamp(t),
-          _metaFlags(metaFlags),
-          _persistedDocumentSize(docId.getSerializedSize()),
-          _size(_persistedDocumentSize + sizeof(DocEntry)),
-          _documentId(new DocumentId(docId)),
-          _document()
-    {
-    }
-
-    DocEntry(Timestamp t, int metaFlags)
-        : _timestamp(t),
-          _metaFlags(metaFlags),
-          _persistedDocumentSize(0),
-          _size(sizeof(DocEntry)),
-          _documentId(),
-          _document()
-    {
-    }
-
-    DocEntry* clone() const {
-        DocEntry* ret;
-        if (_documentId.get() != 0) {
-            ret = new DocEntry(_timestamp, _metaFlags, *_documentId);
-            ret->setPersistedDocumentSize(_persistedDocumentSize);
-        } else if (_document.get()) {
-            ret = new DocEntry(_timestamp, _metaFlags,
-                               Document::UP(new Document(*_document)),
-                               _persistedDocumentSize);
-        } else {
-            ret = new DocEntry(_timestamp, _metaFlags);
-            ret->setPersistedDocumentSize(_persistedDocumentSize);
-        }
-        return ret;
-    }
+    DocEntry(Timestamp t, int metaFlags, DocumentUP doc, size_t serializedDocumentSize);
+    DocEntry(Timestamp t, int metaFlags, const DocumentId& docId);
 
+    DocEntry(Timestamp t, int metaFlags);
+    ~DocEntry();
+    DocEntry* clone() const;
     const Document* getDocument() const { return _document.get(); }
-    const DocumentId* getDocumentId() const {
-        return (_document.get() != 0 ? &_document->getId()
-                                     : _documentId.get());
-    }
-    Document::UP releaseDocument() { return std::move(_document); }
+    const DocumentId* getDocumentId() const;
+    DocumentUP releaseDocument();
     bool isRemove() const { return (_metaFlags & REMOVE_ENTRY); }
     Timestamp getTimestamp() const { return _timestamp; }
-
     int getFlags() const { return _metaFlags; }
     void setFlags(int flags) { _metaFlags = flags; }
     /**
@@ -123,11 +69,7 @@ public:
      * the id alone.
      * Otherwise (i.e. metadata only), returns zero.
      */
-    SizeType getDocumentSize() const
-    {
-        assert(_size >= sizeof(DocEntry));
-        return _size - sizeof(DocEntry);
-    }
+    SizeType getDocumentSize() const;
     /**
      * Return size of document as it exists in persisted form. By default
      * this will return the serialized size of the entry's document instance,
@@ -146,81 +88,9 @@ public:
         _persistedDocumentSize = persistedDocumentSize;
     }
 
-    void print(std::ostream& out, bool, const std::string&) const
-    {
-        out << "DocEntry(" << _timestamp << ", "
-            << _metaFlags << ", ";
-        if (_documentId.get() != 0) {
-            out << *_documentId;
-        } else if (_document.get()) {
-            out << "Doc(" << _document->getId() << ")";
-        } else {
-            out << "metadata only";
-        }
-        out << ")";
-    }
-
-    void prettyPrint(std::ostream& out) const
-    {
-        std::string flags;
-        if (_metaFlags == REMOVE_ENTRY) {
-            flags = " (remove)";
-        }
-
-        out << "DocEntry(Timestamp: " << _timestamp
-            << ", size " << getPersistedDocumentSize() << ", ";
-        if (_documentId.get() != 0) {
-            out << *_documentId;
-        } else if (_document.get()) {
-            out << "Doc(" << _document->getId() << ")";
-        } else {
-            out << "metadata only";
-        }
-        out << flags << ")";
-    }
-
-    bool operator==(const DocEntry& entry) const {
-        if (_timestamp != entry._timestamp) {
-            return false;
-        }
-
-        if (_metaFlags != entry._metaFlags) {
-            return false;
-        }
-
-        if (_documentId.get()) {
-            if (!entry._documentId.get()) {
-                return false;
-            }
-
-            if (*_documentId != *entry._documentId) {
-                return false;
-            }
-        } else {
-            if (entry._documentId.get()) {
-                return false;
-            }
-        }
-
-        if (_document.get()) {
-            if (!entry._document.get()) {
-                return false;
-            }
-
-            if (*_document != *entry._document) {
-                return false;
-            }
-        } else {
-            if (entry._document.get()) {
-                return false;
-            }
-        }
-        if (_persistedDocumentSize != entry._persistedDocumentSize) {
-            return false;
-        }
-
-        return true;
-    }
+    vespalib::string toString() const;
+    void prettyPrint(std::ostream& out) const;
+    bool operator==(const DocEntry& entry) const;
 };
 
 } // spi
diff --git a/persistence/src/vespa/persistence/spi/documentselection.h b/persistence/src/vespa/persistence/spi/documentselection.h
index c3d4f050198..a3dfb9b4c07 100644
--- a/persistence/src/vespa/persistence/spi/documentselection.h
+++ b/persistence/src/vespa/persistence/spi/documentselection.h
@@ -8,22 +8,21 @@
 
 #pragma once
 
-#include <string>
-#include <vespa/document/fieldvalue/document.h>
+#include <persistence/spi/types.h>
 
 namespace storage {
 namespace spi {
 
 class DocumentSelection
 {
-    std::string _documentSelection;
+    vespalib::string _documentSelection;
  public:
-    explicit DocumentSelection(const std::string& docSel)
+    explicit DocumentSelection(const vespalib::string& docSel)
         : _documentSelection(docSel) {}
 
     bool match(const document::Document&) const { return true; }
 
-    const std::string& getDocumentSelection() const {
+    const vespalib::string& getDocumentSelection() const {
         return _documentSelection;
     }
 };
diff --git a/persistence/src/vespa/persistence/spi/metricpersistenceprovider.cpp b/persistence/src/vespa/persistence/spi/metricpersistenceprovider.cpp
index e30ad182e95..0395b52df81 100644
--- a/persistence/src/vespa/persistence/spi/metricpersistenceprovider.cpp
+++ b/persistence/src/vespa/persistence/spi/metricpersistenceprovider.cpp
@@ -25,23 +25,21 @@ namespace {
     typedef MetricPersistenceProvider Impl;
 }
 
+using metrics::LongAverageMetric;
+using std::make_unique;
+
+Impl::ResultMetrics::~ResultMetrics() { }
+
 Impl::ResultMetrics::ResultMetrics(const char* opName)
     : metrics::MetricSet(opName, "", ""),
       _metric(Result::ERROR_COUNT)
 {
-    typedef vespalib::LinkedPtr<metrics::LongAverageMetric> ptr;
-    _metric[Result::NONE] = ptr(
-            new metrics::LongAverageMetric("success", "", "", this));
-    _metric[Result::TRANSIENT_ERROR] = ptr(
-            new metrics::LongAverageMetric("transient_error", "", "", this));
-    _metric[Result::PERMANENT_ERROR] = ptr(
-            new metrics::LongAverageMetric("permanent_error", "", "", this));
-    _metric[Result::TIMESTAMP_EXISTS] = ptr(
-            new metrics::LongAverageMetric("timestamp_exists", "", "", this));
-    _metric[Result::FATAL_ERROR] = ptr(
-            new metrics::LongAverageMetric("fatal_error", "", "", this));
-    _metric[Result::RESOURCE_EXHAUSTED] = ptr(
-            new metrics::LongAverageMetric("resource_exhausted", "", "", this));
+    _metric[Result::NONE] = make_unique<LongAverageMetric>("success", "", "", this);
+    _metric[Result::TRANSIENT_ERROR] = make_unique<LongAverageMetric>("transient_error", "", "", this);
+    _metric[Result::PERMANENT_ERROR] = make_unique<LongAverageMetric>("permanent_error", "", "", this);
+    _metric[Result::TIMESTAMP_EXISTS] = make_unique<LongAverageMetric>("timestamp_exists", "", "", this);
+    _metric[Result::FATAL_ERROR] = make_unique<LongAverageMetric>("fatal_error", "", "", this);
+    _metric[Result::RESOURCE_EXHAUSTED] = make_unique<LongAverageMetric>("resource_exhausted", "", "", this);
     // Assert that the above initialized all entries in vector
     for (size_t i=0; i<_metric.size(); ++i) assert(_metric[i].get());
 }
@@ -76,10 +74,12 @@ Impl::MetricPersistenceProvider(PersistenceProvider& next)
     defineResultMetrics(22, "move");
 }
 
+Impl::~MetricPersistenceProvider() { }
+
 void
 Impl::defineResultMetrics(int index, const char* name)
 {
-    _functionMetrics[index] = ResultMetrics::LP(new ResultMetrics(name));
+    _functionMetrics[index] = make_unique<ResultMetrics>(name);
     registerMetric(*_functionMetrics[index]);
 }
 
@@ -140,7 +140,7 @@ Impl::getBucketInfo(const Bucket& v1) const
 }
 
 Result
-Impl::put(const Bucket& v1, Timestamp v2, const Document::SP& v3, Context& v4)
+Impl::put(const Bucket& v1, Timestamp v2, const DocumentSP& v3, Context& v4)
 {
     PRE_PROCESS(6);
     Result r(_next->put(v1, v2, v3, v4));
@@ -177,8 +177,7 @@ Impl::removeEntry(const Bucket& v1, Timestamp v2, Context& v3)
 }
 
 UpdateResult
-Impl::update(const Bucket& v1, Timestamp v2, const DocumentUpdate::SP& v3,
-             Context& v4)
+Impl::update(const Bucket& v1, Timestamp v2, const DocumentUpdateSP& v3, Context& v4)
 {
     PRE_PROCESS(10);
     UpdateResult r(_next->update(v1, v2, v3, v4));
@@ -196,8 +195,7 @@ Impl::flush(const Bucket& v1, Context& v2)
 }
 
 GetResult
-Impl::get(const Bucket& v1, const document::FieldSet& v2, const DocumentId& v3,
-          Context& v4) const
+Impl::get(const Bucket& v1, const document::FieldSet& v2, const DocumentId& v3, Context& v4) const
 {
     PRE_PROCESS(12);
     GetResult r(_next->get(v1, v2, v3, v4));
diff --git a/persistence/src/vespa/persistence/spi/metricpersistenceprovider.h b/persistence/src/vespa/persistence/spi/metricpersistenceprovider.h
index 168f332614c..1f9884c03c8 100644
--- a/persistence/src/vespa/persistence/spi/metricpersistenceprovider.h
+++ b/persistence/src/vespa/persistence/spi/metricpersistenceprovider.h
@@ -15,55 +15,47 @@ class MetricPersistenceProvider : public PersistenceProvider,
                                   public metrics::MetricSet
 {
     struct ResultMetrics : public metrics::MetricSet {
-        typedef vespalib::LinkedPtr<ResultMetrics> LP;
-        std::vector<vespalib::LinkedPtr<metrics::LongAverageMetric> > _metric;
+        std::vector<std::unique_ptr<metrics::LongAverageMetric> > _metric;
 
         ResultMetrics(const char* opName);
+        ~ResultMetrics();
     };
     PersistenceProvider* _next;
-    std::vector<ResultMetrics::LP> _functionMetrics;
+    std::vector<std::unique_ptr<ResultMetrics>> _functionMetrics;
 
 public:
     typedef std::unique_ptr<MetricPersistenceProvider> UP;
 
     MetricPersistenceProvider(PersistenceProvider&);
+    ~MetricPersistenceProvider();
 
     void setNextProvider(PersistenceProvider& p) { _next = &p; }
 
     // Implementation of the PersistenceProvider API
-    virtual Result initialize();
-    virtual PartitionStateListResult getPartitionStates() const;
-    virtual BucketIdListResult listBuckets(PartitionId) const;
-    virtual Result setClusterState(const ClusterState&);
-    virtual Result setActiveState(const Bucket&, BucketInfo::ActiveState);
-    virtual BucketInfoResult getBucketInfo(const Bucket&) const;
-    virtual Result put(const Bucket&, Timestamp, const Document::SP&, Context&);
-    virtual RemoveResult remove(const Bucket&, Timestamp,
-                                const DocumentId&, Context&);
-    virtual RemoveResult removeIfFound(const Bucket&, Timestamp,
-                                       const DocumentId&, Context&);
-    virtual Result removeEntry(const Bucket&, Timestamp, Context&);
-    virtual UpdateResult update(const Bucket&, Timestamp,
-                                const DocumentUpdate::SP&, Context&);
-    virtual Result flush(const Bucket&, Context&);
-    virtual GetResult get(const Bucket&, const document::FieldSet&,
-                          const DocumentId&, Context&) const;
-    virtual CreateIteratorResult createIterator(
-            const Bucket&, const document::FieldSet&, const Selection&,
-            IncludedVersions, Context&);
-    virtual IterateResult iterate(IteratorId, uint64_t maxByteSize,
-                                  Context&) const;
-    virtual Result destroyIterator(IteratorId, Context&);
-    virtual Result createBucket(const Bucket&, Context&);
-    virtual Result deleteBucket(const Bucket&, Context&);
-    virtual BucketIdListResult getModifiedBuckets() const;
-    virtual Result maintain(const Bucket&,
-                            MaintenanceLevel level);
-    virtual Result split(const Bucket& source, const Bucket& target1,
-                         const Bucket& target2, Context&);
-    virtual Result join(const Bucket& source1, const Bucket& source2,
-                        const Bucket& target, Context&);
-    virtual Result move(const Bucket&, PartitionId target, Context&);
+    Result initialize() override;
+    PartitionStateListResult getPartitionStates() const override;
+    BucketIdListResult listBuckets(PartitionId) const override;
+    Result setClusterState(const ClusterState&) override;
+    Result setActiveState(const Bucket&, BucketInfo::ActiveState) override;
+    BucketInfoResult getBucketInfo(const Bucket&) const override;
+    Result put(const Bucket&, Timestamp, const DocumentSP&, Context&) override;
+    RemoveResult remove(const Bucket&, Timestamp, const DocumentId&, Context&) override;
+    RemoveResult removeIfFound(const Bucket&, Timestamp, const DocumentId&, Context&) override;
+    Result removeEntry(const Bucket&, Timestamp, Context&) override;
+    UpdateResult update(const Bucket&, Timestamp, const DocumentUpdateSP&, Context&) override;
+    Result flush(const Bucket&, Context&) override;
+    GetResult get(const Bucket&, const document::FieldSet&, const DocumentId&, Context&) const override;
+    CreateIteratorResult createIterator(const Bucket&, const document::FieldSet&, const Selection&,
+                                        IncludedVersions, Context&) override;
+    IterateResult iterate(IteratorId, uint64_t maxByteSize, Context&) const override;
+    Result destroyIterator(IteratorId, Context&) override;
+    Result createBucket(const Bucket&, Context&) override;
+    Result deleteBucket(const Bucket&, Context&) override;
+    BucketIdListResult getModifiedBuckets() const override;
+    Result maintain(const Bucket&, MaintenanceLevel level) override;
+    Result split(const Bucket& source, const Bucket& target1, const Bucket& target2, Context&) override;
+    Result join(const Bucket& source1, const Bucket& source2, const Bucket& target, Context&) override;
+    Result move(const Bucket&, PartitionId target, Context&) override;
 
 private:
     void defineResultMetrics(int index, const char* name);
diff --git a/persistence/src/vespa/persistence/spi/partitionstate.cpp b/persistence/src/vespa/persistence/spi/partitionstate.cpp
index 72f0ed863e1..a8618b4bea8 100644
--- a/persistence/src/vespa/persistence/spi/partitionstate.cpp
+++ b/persistence/src/vespa/persistence/spi/partitionstate.cpp
@@ -2,6 +2,8 @@
 
 #include <vespa/fastos/fastos.h>
 #include <vespa/persistence/spi/partitionstate.h>
+#include <vespa/vespalib/util/exceptions.h>
+#include <vespa/vespalib/stllike/asciistream.h>
 
 namespace storage {
 namespace spi {
@@ -9,26 +11,24 @@ namespace spi {
 PartitionState::PartitionState()
     : _state(UP),
       _reason()
-{
-}
+{ }
 
 PartitionState::PartitionState(State s, vespalib::stringref reason)
     : _state(s),
       _reason(reason)
-{
-}
-
+{ }
 
 PartitionStateList::PartitionStateList(PartitionId::Type partitionCount)
     : _states(partitionCount)
-{
-}
+{ }
+
+PartitionStateList::~PartitionStateList() { }
 
 PartitionState&
 PartitionStateList::operator[](PartitionId::Type index)
 {
     if (index >= _states.size()) {
-        std::ostringstream ost;
+        vespalib::asciistream ost;
         ost << "Cannot return disk " << index << " of " << _states.size();
         throw vespalib::IllegalArgumentException(ost.str(), VESPA_STRLOC);
     }
diff --git a/persistence/src/vespa/persistence/spi/partitionstate.h b/persistence/src/vespa/persistence/spi/partitionstate.h
index 296945b4444..5ca797674af 100644
--- a/persistence/src/vespa/persistence/spi/partitionstate.h
+++ b/persistence/src/vespa/persistence/spi/partitionstate.h
@@ -40,6 +40,7 @@ class PartitionStateList {
 
 public:
     PartitionStateList(PartitionId::Type partitionCount);
+    ~PartitionStateList();
 
     PartitionState& operator[](PartitionId::Type index);
     const PartitionState& operator[](PartitionId::Type index) const
diff --git a/persistence/src/vespa/persistence/spi/persistenceprovider.h b/persistence/src/vespa/persistence/spi/persistenceprovider.h
index 9e0088214b8..ae7ec6bb6da 100644
--- a/persistence/src/vespa/persistence/spi/persistenceprovider.h
+++ b/persistence/src/vespa/persistence/spi/persistenceprovider.h
@@ -9,9 +9,11 @@
 #include <vespa/persistence/spi/partitionstate.h>
 #include <vespa/persistence/spi/result.h>
 #include <vespa/persistence/spi/selection.h>
-#include <persistence/spi/types.h>
 #include <vespa/persistence/spi/clusterstate.h>
-#include <vespa/document/fieldset/fieldset.h>
+
+namespace document {
+    class FieldSet;
+}
 
 namespace storage {
 namespace spi {
@@ -110,7 +112,7 @@ struct PersistenceProvider
     /**
      * Store the given document at the given microsecond time.
      */
-    virtual Result put(const Bucket&, Timestamp, const Document::SP&, Context&) = 0;
+    virtual Result put(const Bucket&, Timestamp, const DocumentSP&, Context&) = 0;
 
     /**
      * This remove function assumes that there exist something to be removed.
@@ -208,7 +210,7 @@ struct PersistenceProvider
      */
     virtual UpdateResult update(const Bucket&,
                                 Timestamp timestamp,
-                                const DocumentUpdate::SP& update,
+                                const DocumentUpdateSP& update,
                                 Context&) = 0;
 
     /**
diff --git a/persistence/src/vespa/persistence/spi/result.cpp b/persistence/src/vespa/persistence/spi/result.cpp
new file mode 100644
index 00000000000..2991b51d6ad
--- /dev/null
+++ b/persistence/src/vespa/persistence/spi/result.cpp
@@ -0,0 +1,30 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "result.h"
+#include <vespa/document/fieldvalue/document.h>
+
+namespace storage {
+
+namespace spi {
+
+vespalib::string
+Result::toString() const {
+    vespalib::asciistream os;
+    os << "Result(" << _errorCode << ", " << _errorMessage << ")";
+    return os.str();
+}
+
+GetResult::GetResult(Document::UP doc, Timestamp timestamp)
+    : Result(),
+      _timestamp(timestamp),
+      _doc(std::move(doc))
+{ }
+
+GetResult::~GetResult() { }
+BucketIdListResult::~BucketIdListResult() { }
+
+IterateResult::~IterateResult() { }
+
+}  // namespace spi
+}  // namespace storage
+
diff --git a/persistence/src/vespa/persistence/spi/result.h b/persistence/src/vespa/persistence/spi/result.h
index 80d5ff585d9..14956feddf5 100644
--- a/persistence/src/vespa/persistence/spi/result.h
+++ b/persistence/src/vespa/persistence/spi/result.h
@@ -2,15 +2,15 @@
 #pragma once
 
 #include "partitionstate.h"
-#include <vespa/persistence/spi/bucketinfo.h>
-#include <vespa/persistence/spi/docentry.h>
-#include <persistence/spi/types.h>
+#include "bucketinfo.h"
+#include "bucket.h"
+#include "docentry.h"
 
 namespace storage {
 
 namespace spi {
 
-class Result : public document::Printable {
+class Result {
 public:
     typedef std::unique_ptr<Result> UP;
 
@@ -36,6 +36,8 @@ public:
         : _errorCode(error),
           _errorMessage(errorMessage) {}
 
+    virtual ~Result() { }
+
     bool operator==(const Result& o) const {
         return _errorCode == o._errorCode
                && _errorMessage == o._errorMessage;
@@ -53,10 +55,7 @@ public:
         return _errorMessage;
     }
 
-    void print(std::ostream& out, bool, const std::string&) const
-    {
-        out << "Result(" << _errorCode << ", " << _errorMessage << ")";
-    }
+    vespalib::string toString() const;
 
 private:
     ErrorType _errorCode;
@@ -97,13 +96,13 @@ public:
      */
     UpdateResult(ErrorType error, const vespalib::string& errorMessage)
         : Result(error, errorMessage),
-          _existingTimestamp(0) {}
+          _existingTimestamp(0) { }
 
     /**
      * Constructor to use when no document to update was found.
      */
     UpdateResult()
-        : _existingTimestamp(0) {}
+        : _existingTimestamp(0) { }
 
     /**
      * Constructor to use when the update was successful.
@@ -129,17 +128,15 @@ public:
     RemoveResult(ErrorType error, const vespalib::string& errorMessage)
         : Result(error, errorMessage),
           _wasFound(false)
-    {}
+    { }
 
     /**
      * Constructor to use when the remove was successful.
      */
     RemoveResult(bool foundDocument)
-        : _wasFound(foundDocument) {};
+        : _wasFound(foundDocument) { }
 
-    bool wasFound() const {
-        return _wasFound;
-    }
+    bool wasFound() const { return _wasFound; }
 
 private:
     bool _wasFound;
@@ -153,13 +150,13 @@ public:
      */
     GetResult(ErrorType error, const vespalib::string& errorMessage)
         : Result(error, errorMessage),
-          _timestamp(0) {};
+          _timestamp(0) { }
 
     /**
      * Constructor to use when we didn't find the document in question.
      */
     GetResult()
-        : _timestamp(0) {};
+        : _timestamp(0) { }
 
     /**
      * Constructor to use when we found the document asked for.
@@ -167,11 +164,9 @@ public:
      * @param doc The document we found
      * @param timestamp The timestamp with which the document was stored.
      */
-    GetResult(Document::UP doc, Timestamp timestamp)
-        : Result(),
-          _timestamp(timestamp),
-          _doc(std::move(doc))
-    {}
+    GetResult(DocumentUP doc, Timestamp timestamp);
+
+    ~GetResult();
 
     Timestamp getTimestamp() const { return _timestamp; }
 
@@ -187,13 +182,13 @@ public:
         return *_doc;
     }
 
-    const Document::SP & getDocumentPtr() {
+    const DocumentSP & getDocumentPtr() {
         return _doc;
     }
 
 private:
-    Timestamp _timestamp;
-    Document::SP _doc;
+    Timestamp  _timestamp;
+    DocumentSP _doc;
 };
 
 class BucketIdListResult : public Result {
@@ -204,7 +199,7 @@ public:
      * Constructor used when there was an error listing the buckets.
      */
     BucketIdListResult(ErrorType error, const vespalib::string& errorMessage)
-        : Result(error, errorMessage) {};
+        : Result(error, errorMessage) {}
 
     /**
      * Constructor used when the bucket listing was successful.
@@ -216,7 +211,9 @@ public:
         : Result()
     {
         _info.swap(list);
-    };
+    }
+
+    ~BucketIdListResult();
 
     const List& getList() const { return _info; }
     List& getList() { return _info; }
@@ -232,14 +229,14 @@ public:
      */
     CreateIteratorResult(ErrorType error, const vespalib::string& errorMessage)
         : Result(error, errorMessage),
-          _iterator(0) {};
+          _iterator(0) { }
 
     /**
      * Constructor used when the iterator state was successfully created.
      */
     CreateIteratorResult(const IteratorId& id)
         : _iterator(id)
-    {}
+    { }
 
     const IteratorId& getIteratorId() const { return _iterator; }
 
@@ -257,7 +254,7 @@ public:
     IterateResult(ErrorType error, const vespalib::string& errorMessage)
         : Result(error, errorMessage),
           _completed(false)
-    {}
+    { }
 
     /**
      * Constructor used when the iteration was successful.
@@ -271,6 +268,8 @@ public:
           _entries(std::move(entries))
     { }
 
+    ~IterateResult();
+
     const List& getEntries() const { return _entries; }
 
     bool isCompleted() const { return _completed; }
@@ -289,14 +288,14 @@ public:
     PartitionStateListResult(ErrorType error, const vespalib::string& msg)
         : Result(error, msg),
           _list(0)
-    {}
+    { }
 
     /**
      * Constructor to use when the operation was successful.
      */
-    PartitionStateListResult(PartitionStateList list) : _list(list) {};
+    PartitionStateListResult(PartitionStateList list) : _list(list) { }
 
-    PartitionStateList getList() const { return _list; }
+    const PartitionStateList & getList() const { return _list; }
 
 private:
     PartitionStateList _list;
diff --git a/persistence/src/vespa/persistence/spi/selection.h b/persistence/src/vespa/persistence/spi/selection.h
index 260a85992f7..84408d63517 100644
--- a/persistence/src/vespa/persistence/spi/selection.h
+++ b/persistence/src/vespa/persistence/spi/selection.h
@@ -8,9 +8,6 @@
 
 #pragma once
 
-#include <map>
-#include <vector>
-#include <persistence/spi/types.h>
 #include <vespa/persistence/spi/documentselection.h>
 
 namespace storage {
@@ -25,9 +22,9 @@ public:
     typedef std::vector<Timestamp> TimestampSubset;
 private:
     DocumentSelection _documentSelection;
-    Timestamp _fromTimestamp;
-    Timestamp _toTimestamp;
-    TimestampSubset _timestampSubset;
+    Timestamp         _fromTimestamp;
+    Timestamp         _toTimestamp;
+    TimestampSubset   _timestampSubset;
 
 public:
     Selection(const DocumentSelection& docSel)
@@ -35,7 +32,7 @@ public:
           _fromTimestamp(0),
           _toTimestamp(INT64_MAX),
           _timestampSubset()
-        {}
+    { }
 
     const DocumentSelection& getDocumentSelection() const {
         return _documentSelection;
@@ -75,17 +72,10 @@ public:
     Timestamp getFromTimestamp() const { return _fromTimestamp; }
     Timestamp getToTimestamp() const { return _toTimestamp; }
 
-    std::string requiredFields();
-
     /**
      * Regular usage.
      */
     bool match(const Document& doc, const MetaData& metaData) const;
-
-    /**
-     * Can be used if requiredFields is empty.
-     */
-    bool match(const MetaData& metaData) const;
 };
 
 } // spi