Merge pull request #1844 from yahoo/arnej/remove-nonslime-summary-code

Arnej/remove nonslime summary code

7 files changed, 62 insertions, 308 deletions

diff --git a/vsm/src/tests/docsum/docsum.cpp b/vsm/src/tests/docsum/docsum.cpp
index 4ebd7061b69..51894ec3eb1 100644
--- a/vsm/src/tests/docsum/docsum.cpp
+++ b/vsm/src/tests/docsum/docsum.cpp
@@ -5,7 +5,7 @@
 #include <vespa/document/fieldvalue/fieldvalues.h>
 #include <vespa/vsm/common/docsum.h>
 #include <vespa/vsm/vsm/flattendocsumwriter.h>
-#include <vespa/vsm/vsm/jsondocsumwriter.h>
+#include <vespa/vsm/vsm/slimefieldwriter.h>
 
 using namespace document;
 
@@ -56,15 +56,15 @@ private:
         assertFlattenDocsumWriter(fdw, fv, exp);
     }
     void assertFlattenDocsumWriter(FlattenDocsumWriter & fdw, const FieldValue & fv, const std::string & exp);
-    void assertJSONDocsumWriter(const FieldValue & fv, const std::string & exp) {
-        JSONDocsumWriter jdw;
-        assertJSONDocsumWriter(jdw, fv, exp);
+    void assertSlimeFieldWriter(const FieldValue & fv, const std::string & exp) {
+        SlimeFieldWriter sfw;
+        assertSlimeFieldWriter(sfw, fv, exp);
     }
-    void assertJSONDocsumWriter(JSONDocsumWriter & jdw, const FieldValue & fv, const std::string & exp);
+    void assertSlimeFieldWriter(SlimeFieldWriter & sfw, const FieldValue & fv, const std::string & exp);
 
     void testFlattenDocsumWriter();
-    void testJSONDocsumWriter();
-    void requireThatJSONDocsumWriterHandlesMap();
+    void testSlimeFieldWriter();
+    void requireThatSlimeFieldWriterHandlesMap();
     void testDocSumCache();
 
 public:
@@ -104,10 +104,19 @@ DocsumTest::assertFlattenDocsumWriter(FlattenDocsumWriter & fdw, const FieldValu
 }
 
 void
-DocsumTest::assertJSONDocsumWriter(JSONDocsumWriter & jdw, const FieldValue & fv, const std::string & exp)
+DocsumTest::assertSlimeFieldWriter(SlimeFieldWriter & sfw, const FieldValue & fv, const std::string & exp)
 {
-    jdw.write(fv);
-    EXPECT_EQUAL(jdw.getResult(), exp);
+    sfw.convert(fv);
+
+    vespalib::Slime gotSlime;
+    vespalib::Memory serialized(sfw.out());
+    size_t decodeRes = vespalib::slime::BinaryFormat::decode(serialized, gotSlime);
+    ASSERT_EQUAL(decodeRes, serialized.size);
+
+    vespalib::Slime expSlime;
+    size_t used = vespalib::slime::JsonFormat::decode(exp, expSlime);
+    EXPECT_EQUAL(exp.size(), used);
+    EXPECT_EQUAL(expSlime, gotSlime);
 }
 
 void
@@ -147,20 +156,20 @@ DocsumTest::testFlattenDocsumWriter()
 }
 
 void
-DocsumTest::testJSONDocsumWriter()
+DocsumTest::testSlimeFieldWriter()
 {
     { // basic types
-        assertJSONDocsumWriter(LongFieldValue(123456789), "123456789");
-        assertJSONDocsumWriter(FloatFieldValue(12.34), "12.34");
-        assertJSONDocsumWriter(StringFieldValue("foo bar"), "\"foo bar\"");
+        assertSlimeFieldWriter(LongFieldValue(123456789), "123456789");
+        assertSlimeFieldWriter(DoubleFieldValue(12.34), "12.34");
+        assertSlimeFieldWriter(StringFieldValue("foo bar"), "\"foo bar\"");
     }
     { // collection field values
-        assertJSONDocsumWriter(createFieldValue(StringList().add("foo").add("bar").add("baz")),
+        assertSlimeFieldWriter(createFieldValue(StringList().add("foo").add("bar").add("baz")),
                                "[\"foo\",\"bar\",\"baz\"]");
-        assertJSONDocsumWriter(createFieldValue(WeightedStringList().add(std::make_pair("bar", 20)).
+        assertSlimeFieldWriter(createFieldValue(WeightedStringList().add(std::make_pair("bar", 20)).
                                                                      add(std::make_pair("baz", 30)).
                                                                      add(std::make_pair("foo", 10))),
-                               "[[\"bar\",20],[\"baz\",30],[\"foo\",10]]");
+                               "[{item:\"bar\",weight:20},{item:\"baz\",weight:30},{item:\"foo\",weight:10}]");
     }
     { // struct field value
         StructDataType subType("substruct");
@@ -186,36 +195,39 @@ DocsumTest::testJSONDocsumWriter()
 
 
         { // select a subset and then all
-            JSONDocsumWriter jdw;
+            SlimeFieldWriter sfw;
             DocsumFieldSpec::FieldIdentifierVector fields;
             fields.push_back(DocsumFieldSpec::FieldIdentifier(
                             0, *type.buildFieldPath("a")));
             fields.push_back(DocsumFieldSpec::FieldIdentifier(
                             0, *type.buildFieldPath("c.e")));
-            jdw.setInputFields(fields);
-            assertJSONDocsumWriter(jdw, value, "{\"a\":\"foo\",\"c\":{\"e\":\"qux\"}}");
-            jdw.clear();
-            assertJSONDocsumWriter(jdw, value, "{\"a\":\"foo\",\"b\":\"bar\",\"c\":{\"d\":\"baz\",\"e\":\"qux\"}}");
+            sfw.setInputFields(fields);
+            assertSlimeFieldWriter(sfw, value, "{\"a\":\"foo\",\"c\":{\"e\":\"qux\"}}");
+            sfw.clear();
+            assertSlimeFieldWriter(sfw, value, "{\"a\":\"foo\",\"b\":\"bar\",\"c\":{\"d\":\"baz\",\"e\":\"qux\"}}");
         }
-    }
+
     { // multiple invocations
-        JSONDocsumWriter jdw;
-        assertJSONDocsumWriter(jdw, StringFieldValue("foo"), "\"foo\"");
-        assertJSONDocsumWriter(jdw, StringFieldValue("bar"), "\"foo\"\"bar\"");
-        jdw.clear();
-        assertJSONDocsumWriter(jdw, StringFieldValue("baz"), "\"baz\"");
+        SlimeFieldWriter sfw;
+        assertSlimeFieldWriter(sfw, StringFieldValue("foo"), "\"foo\"");
+        sfw.clear();
+        assertSlimeFieldWriter(sfw, StringFieldValue("bar"), "\"bar\"");
+        sfw.clear();
+        assertSlimeFieldWriter(sfw, StringFieldValue("baz"), "\"baz\"");
+    }
+
     }
 }
 
 void
-DocsumTest::requireThatJSONDocsumWriterHandlesMap()
+DocsumTest::requireThatSlimeFieldWriterHandlesMap()
 {
     { // map<string, string>
         MapDataType mapType(*DataType::STRING, *DataType::STRING);
         MapFieldValue mapfv(mapType);
         EXPECT_TRUE(mapfv.put(StringFieldValue("k1"), StringFieldValue("v1")));
         EXPECT_TRUE(mapfv.put(StringFieldValue("k2"), StringFieldValue("v2")));
-        assertJSONDocsumWriter(mapfv, "[{\"key\":\"k1\",\"value\":\"v1\"},{\"key\":\"k2\",\"value\":\"v2\"}]");
+        assertSlimeFieldWriter(mapfv, "[{\"key\":\"k1\",\"value\":\"v1\"},{\"key\":\"k2\",\"value\":\"v2\"}]");
     }
     { // map<string, struct>
         StructDataType structType("struct");
@@ -230,17 +242,17 @@ DocsumTest::requireThatJSONDocsumWriterHandlesMap()
         MapFieldValue mapfv(mapType);
         EXPECT_TRUE(mapfv.put(StringFieldValue("k1"), structValue));
         { // select a subset and then all
-            JSONDocsumWriter jdw;
+            SlimeFieldWriter sfw;
             DocsumFieldSpec::FieldIdentifierVector fields;
             fields.push_back(DocsumFieldSpec::FieldIdentifier(0, *mapType.buildFieldPath("value.b")));
-            jdw.setInputFields(fields);
-            assertJSONDocsumWriter(jdw, mapfv, "[{\"key\":\"k1\",\"value\":{\"b\":\"bar\"}}]");
+            sfw.setInputFields(fields);
+            assertSlimeFieldWriter(sfw, mapfv, "[{\"key\":\"k1\",\"value\":{\"b\":\"bar\"}}]");
             fields[0] = DocsumFieldSpec::FieldIdentifier(0, *mapType.buildFieldPath("{k1}.a"));
-            jdw.clear();
-            jdw.setInputFields(fields);
-            assertJSONDocsumWriter(jdw, mapfv, "[{\"key\":\"k1\",\"value\":{\"a\":\"foo\"}}]");
-            jdw.clear(); // all fields implicit
-            assertJSONDocsumWriter(jdw, mapfv, "[{\"key\":\"k1\",\"value\":{\"a\":\"foo\",\"b\":\"bar\"}}]");
+            sfw.clear();
+            sfw.setInputFields(fields);
+            assertSlimeFieldWriter(sfw, mapfv, "[{\"key\":\"k1\",\"value\":{\"a\":\"foo\"}}]");
+            sfw.clear(); // all fields implicit
+            assertSlimeFieldWriter(sfw, mapfv, "[{\"key\":\"k1\",\"value\":{\"a\":\"foo\",\"b\":\"bar\"}}]");
         }
     }
 }
@@ -251,8 +263,8 @@ DocsumTest::Main()
     TEST_INIT("docsum_test");
 
     testFlattenDocsumWriter();
-    testJSONDocsumWriter();
-    requireThatJSONDocsumWriterHandlesMap();
+    testSlimeFieldWriter();
+    requireThatSlimeFieldWriterHandlesMap();
 
     TEST_DONE();
 }
diff --git a/vsm/src/vespa/vsm/vsm/CMakeLists.txt b/vsm/src/vespa/vsm/vsm/CMakeLists.txt
index 237b0771c95..9df5f1c2957 100644
--- a/vsm/src/vespa/vsm/vsm/CMakeLists.txt
+++ b/vsm/src/vespa/vsm/vsm/CMakeLists.txt
@@ -5,7 +5,6 @@ vespa_add_library(vsm_vsmbase OBJECT
     docsumfilter.cpp
     fieldsearchspec.cpp
     flattendocsumwriter.cpp
-    jsondocsumwriter.cpp
     slimefieldwriter.cpp
     snippetmodifier.cpp
     vsm-adapter.cpp
diff --git a/vsm/src/vespa/vsm/vsm/docsumfilter.cpp b/vsm/src/vespa/vsm/vsm/docsumfilter.cpp
index eb4e0bf532f..e858c8ca8a6 100644
--- a/vsm/src/vespa/vsm/vsm/docsumfilter.cpp
+++ b/vsm/src/vespa/vsm/vsm/docsumfilter.cpp
@@ -1,11 +1,9 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "docsumfilter.h"
-#include "jsondocsumwriter.h"
 #include "slimefieldwriter.h"
 #include <vespa/searchsummary/docsummary/resultclass.h>
 #include <vespa/searchsummary/docsummary/summaryfieldconverter.h>
-#include <vespa/vespalib/util/jsonwriter.h>
 #include <vespa/document/fieldvalue/literalfieldvalue.h>
 #include <vespa/document/base/exceptions.h>
 #include <vespa/log/log.h>
@@ -216,7 +214,6 @@ DocsumFilter::DocsumFilter(const DocsumToolsPtr &tools, const IDocSumCache & doc
     _fields(),
     _highestFieldNo(0),
     _packer(tools.get() ? tools->getResultConfig() : NULL),
-    _jsonWriter(),
     _flattenWriter(),
     _snippetModifiers(NULL),
     _cachedValue(),
@@ -316,33 +313,6 @@ DocsumFilter::writeField(const document::FieldValue & fv, const FieldPath & path
     }
 }
 
-void
-DocsumFilter::writeJSONField(const DocsumFieldSpec & fieldSpec,
-                             const Document & docsum,
-                             ResultPacker & packer)
-{
-    if (fieldSpec.getCommand() == VsmsummaryConfig::Fieldmap::NONE) {
-        const DocsumFieldSpec::FieldIdentifier & fieldId = fieldSpec.getOutputField();
-        const document::FieldValue * fv = docsum.getField(fieldId.getId());
-        if (fv != NULL) {
-            LOG(debug, "writeJSONField: About to write field '%d' as JSONSTRING: field value = '%s'",
-                fieldId.getId(), fv->toString().c_str());
-            if (!fieldSpec.hasIdentityMapping()) {
-                _jsonWriter.setInputFields(fieldSpec.getInputFields());
-            }
-            _jsonWriter.write(*fv);
-            vespalib::string s = _jsonWriter.getResult();
-            packer.AddLongString(s.c_str(), s.size());
-            _jsonWriter.clear();
-        } else {
-            LOG(debug, "writeJSONField: Field value not set for field '%d'", fieldId.getId());
-            packer.AddEmpty();
-        }
-    } else {
-        LOG(debug, "writeJSONField: Cannot handle this command");
-        packer.AddEmpty();
-    }
-}
 
 void
 DocsumFilter::writeSlimeField(const DocsumFieldSpec & fieldSpec,
@@ -467,7 +437,7 @@ DocsumFilter::getSummaryClassId() const
 }
 
 DocsumStoreValue
-DocsumFilter::getMappedDocsum(uint32_t id, bool useSlimeInsideFields)
+DocsumFilter::getMappedDocsum(uint32_t id)
 {
     const ResultClass *resClass = _tools->getResultClass();
     if (resClass == NULL) {
@@ -476,17 +446,12 @@ DocsumFilter::getMappedDocsum(uint32_t id, bool useSlimeInsideFields)
 
     const Document & doc = _docsumCache->getDocSum(id);
 
-    LOG(spam, "getMappedDocsum %u [useSlimeInsideFields=%s]", id, useSlimeInsideFields ? "true" : "false");
-
     _packer.Init(resClass->GetClassID());
     for (FieldSpecList::iterator it(_fields.begin()), end = _fields.end(); it != end; ++it) {
         ResType type = it->getResultType();
         if (type == RES_JSONSTRING || type == RES_XMLSTRING) {
-            if (useSlimeInsideFields) {
-                writeSlimeField(*it, doc, _packer);
-            } else {
-                writeJSONField(*it, doc, _packer);
-            }
+            // this really means 'structured data'
+            writeSlimeField(*it, doc, _packer);
         } else {
             if (it->getInputFields().size() == 1 && it->getCommand() == VsmsummaryConfig::Fieldmap::NONE) {
                 const DocsumFieldSpec::FieldIdentifier & fieldId = it->getInputFields()[0];
diff --git a/vsm/src/vespa/vsm/vsm/docsumfilter.h b/vsm/src/vespa/vsm/vsm/docsumfilter.h
index 370843a3789..d39526a2575 100644
--- a/vsm/src/vespa/vsm/vsm/docsumfilter.h
+++ b/vsm/src/vespa/vsm/vsm/docsumfilter.h
@@ -9,7 +9,6 @@
 #include <vespa/vsm/vsm/docsumfieldspec.h>
 #include <vespa/vsm/vsm/fieldsearchspec.h>
 #include <vespa/vsm/vsm/flattendocsumwriter.h>
-#include <vespa/vsm/vsm/jsondocsumwriter.h>
 #include <vespa/vsm/vsm/vsm-adapter.h>
 #include <vespa/searchsummary/docsummary/resultpacker.h>
 #include <vespa/searchsummary/docsummary/docsumstore.h>
@@ -38,7 +37,6 @@ private:
     FieldSpecList         _fields;        // list of summary fields to generate
     size_t                _highestFieldNo;
     ResultPacker          _packer;
-    JSONDocsumWriter      _jsonWriter;
     FlattenDocsumWriter   _flattenWriter;
     const FieldModifierMap * _snippetModifiers;
     document::FieldValue::UP _cachedValue;
@@ -52,7 +50,6 @@ private:
                                                VsmsummaryConfig::Fieldmap::Command command,
                                                const Document & docsum, bool & modified);
     void writeField(const document::FieldValue & fv, const FieldPath & path, ResType type, ResultPacker & packer);
-    void writeJSONField(const DocsumFieldSpec & fieldSpec, const Document & docsum, ResultPacker & packer);
     void writeSlimeField(const DocsumFieldSpec & fieldSpec, const Document & docsum, ResultPacker & packer);
     void writeFlattenField(const DocsumFieldSpec & fieldSpec, const Document & docsum, ResultPacker & packer);
     void writeEmpty(ResType type, ResultPacker & packer);
@@ -86,7 +83,7 @@ public:
     void setDocSumStore(const IDocSumCache & docsumCache) { _docsumCache = &docsumCache; }
 
     // Inherit doc from IDocsumStore
-    DocsumStoreValue getMappedDocsum(uint32_t id, bool useSlimeInsideFields) override;
+    DocsumStoreValue getMappedDocsum(uint32_t id) override;
     uint32_t getNumDocs() const override;
     uint32_t getSummaryClassId() const override;
 };
diff --git a/vsm/src/vespa/vsm/vsm/jsondocsumwriter.cpp b/vsm/src/vespa/vsm/vsm/jsondocsumwriter.cpp
deleted file mode 100644
index e05f69d572a..00000000000
--- a/vsm/src/vespa/vsm/vsm/jsondocsumwriter.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "jsondocsumwriter.h"
-#include <vespa/vespalib/stllike/asciistream.h>
-
-#include <vespa/log/log.h>
-LOG_SETUP(".vsm.jsondocsumwriter");
-
-namespace {
-
-vespalib::string
-toString(const vsm::FieldPath & fp)
-{
-    vespalib::asciistream oss;
-    for (size_t i = 0; i < fp.size(); ++i) {
-        if (i > 0) {
-            oss << ".";
-        }
-        oss << fp[i].getName();
-    }
-    return oss.str();
-}
-
-}
-
-namespace vsm {
-
-void
-JSONDocsumWriter::traverseRecursive(const document::FieldValue & fv)
-{
-    LOG(debug, "traverseRecursive: class(%s), fieldValue(%s), currentPath(%s)",
-        fv.getClass().name(), fv.toString().c_str(), toString(_currPath).c_str());
-
-    if (fv.getClass().inherits(document::CollectionFieldValue::classId)) {
-        const document::CollectionFieldValue & cfv = static_cast<const document::CollectionFieldValue &>(fv);
-        if (cfv.inherits(document::ArrayFieldValue::classId)) {
-            const document::ArrayFieldValue & afv = static_cast<const document::ArrayFieldValue &>(cfv);
-            _output.beginArray();
-            for (size_t i = 0; i < afv.size(); ++i) {
-                const document::FieldValue & nfv = afv[i];
-                traverseRecursive(nfv);
-            }
-            _output.endArray();
-        } else if (cfv.inherits(document::WeightedSetFieldValue::classId)) {
-            const document::WeightedSetFieldValue & wsfv = static_cast<const document::WeightedSetFieldValue &>(cfv);
-            _output.beginArray();
-            for (document::WeightedSetFieldValue::const_iterator itr = wsfv.begin(); itr != wsfv.end(); ++itr) {
-                const document::FieldValue & nfv = *itr->first;
-                _output.beginArray();
-                traverseRecursive(nfv);
-                _output.appendInt64(static_cast<const document::IntFieldValue&>(*itr->second).getValue());
-                _output.endArray();
-            }
-            _output.endArray();
-        } else {
-            LOG(warning, "traverseRecursive: Cannot handle collection field value of type '%s'",
-                fv.getClass().name());
-        }
-
-    } else if (fv.getClass().inherits(document::MapFieldValue::classId)) {
-        const document::MapFieldValue & mfv = static_cast<const document::MapFieldValue &>(fv);
-        _output.beginArray();
-        for (document::MapFieldValue::const_iterator itr = mfv.begin(); itr != mfv.end(); ++itr) {
-            _output.beginObject();
-            _output.appendKey("key");
-            traverseRecursive(*itr->first);
-            _output.appendKey("value");
-            const document::MapDataType& mapType = static_cast<const document::MapDataType &>(*mfv.getDataType());
-            document::FieldPathEntry valueEntry(
-                    mapType, mapType.getKeyType(), mapType.getValueType(),
-                    false, true);
-            _currPath.push_back(valueEntry);
-            traverseRecursive(*itr->second);
-            _currPath.pop_back();
-            _output.endObject();
-        }
-        _output.endArray();
-    } else if (fv.getClass().inherits(document::StructuredFieldValue::classId)) {
-        const document::StructuredFieldValue & sfv = static_cast<const document::StructuredFieldValue &>(fv);
-        _output.beginObject();
-        for (document::StructuredFieldValue::const_iterator itr = sfv.begin(); itr != sfv.end(); ++itr) {
-            // TODO: Why do we have to iterate like this?
-            document::FieldPathEntry fi(sfv.getField(itr.field().getName()));
-            _currPath.push_back(fi);
-            if (explorePath()) {
-                _output.appendKey(itr.field().getName());
-                document::FieldValue::UP fval(sfv.getValue(itr.field()));
-                traverseRecursive(*fval);
-            }
-            _currPath.pop_back();
-        }
-        _output.endObject();
-
-    } else {
-        if (fv.getClass().inherits(document::LiteralFieldValueB::classId)) {
-            const document::LiteralFieldValueB & lfv = static_cast<const document::LiteralFieldValueB &>(fv);
-            _output.appendString(lfv.getValueRef());
-        } else if (fv.getClass().inherits(document::NumericFieldValueBase::classId)) {
-            switch (fv.getDataType()->getId()) {
-            case document::DataType::T_BYTE:
-            case document::DataType::T_SHORT:
-            case document::DataType::T_INT:
-            case document::DataType::T_LONG:
-                _output.appendInt64(fv.getAsLong());
-                break;
-            case document::DataType::T_FLOAT:
-                _output.appendFloat(fv.getAsFloat());
-                break;
-            case document::DataType::T_DOUBLE:
-                _output.appendDouble(fv.getAsFloat());
-                break;
-            default:
-                _output.appendString(fv.getAsString());
-            }
-        } else {
-            _output.appendString(fv.toString());
-        }
-    }
-}
-
-bool
-JSONDocsumWriter::explorePath()
-{
-    if (_inputFields == NULL) {
-        return true;
-    }
-    // find out if we should explore the current path
-    for (size_t i = 0; i < _inputFields->size(); ++i) {
-        const FieldPath & fp = (*_inputFields)[i].getPath();
-        if (_currPath.size() <= fp.size()) {
-            bool equal = true;
-            for (size_t j = 0; j < _currPath.size() && equal; ++j) {
-                equal = (fp[j].getName() == _currPath[j].getName());
-            }
-            if (equal) {
-                // the current path matches one of the input field paths
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-JSONDocsumWriter::JSONDocsumWriter() :
-    _output(),
-    _inputFields(NULL),
-    _currPath()
-{
-}
-
-void
-JSONDocsumWriter::write(const document::FieldValue & fv)
-{
-    if (LOG_WOULD_LOG(debug)) {
-        if (_inputFields != NULL) {
-            for (size_t i = 0; i < _inputFields->size(); ++i) {
-                LOG(debug, "write: input field path [%zd] '%s'", i, toString((*_inputFields)[i].getPath()).c_str());
-            }
-        } else {
-            LOG(debug, "write: no input fields");
-        }
-    }
-    traverseRecursive(fv);
-}
-
-void
-JSONDocsumWriter::clear()
-{
-    _output.clear();
-    _inputFields = NULL;
-    _currPath.clear();
-}
-
-}
diff --git a/vsm/src/vespa/vsm/vsm/jsondocsumwriter.h b/vsm/src/vespa/vsm/vsm/jsondocsumwriter.h
deleted file mode 100644
index 569d3a088d7..00000000000
--- a/vsm/src/vespa/vsm/vsm/jsondocsumwriter.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#pragma once
-
-#include <vespa/document/fieldvalue/fieldvalues.h>
-#include <vespa/vespalib/util/jsonwriter.h>
-#include <vespa/vsm/common/storagedocument.h>
-#include <vespa/vsm/vsm/docsumfieldspec.h>
-
-namespace vsm {
-
-/**
- * This class is used to write a field value as a json string.
- * If only a subset of the field value should be written this subset
- * is specified using the setInputFields() function.
- **/
-class JSONDocsumWriter
-{
-private:
-    vespalib::JSONStringer _output;
-    const DocsumFieldSpec::FieldIdentifierVector * _inputFields;
-    FieldPath _currPath;
-
-    void traverseRecursive(const document::FieldValue & fv);
-    bool explorePath();
-
-public:
-    JSONDocsumWriter();
-
-    /**
-     * Specifies the subset of the field value that should be written.
-     **/
-    void setInputFields(const DocsumFieldSpec::FieldIdentifierVector & inputFields) { _inputFields = &inputFields; }
-
-    /**
-     * Writes the given field value using the underlying JSONStringer.
-     **/
-    void write(const document::FieldValue & fv);
-
-    /**
-     * Returns the result as a string.
-     **/
-    vespalib::string getResult() { return _output.toString(); }
-
-    /**
-     * Clears this instance such that it is ready to write a new field value.
-     **/
-    void clear();
-};
-
-}
-
diff --git a/vsm/src/vespa/vsm/vsm/slimefieldwriter.h b/vsm/src/vespa/vsm/vsm/slimefieldwriter.h
index 0d2856e3e9b..ac540b2ccfe 100644
--- a/vsm/src/vespa/vsm/vsm/slimefieldwriter.h
+++ b/vsm/src/vespa/vsm/vsm/slimefieldwriter.h
@@ -44,6 +44,12 @@ public:
     vespalib::stringref out() const {
         return vespalib::stringref(_rbuf.GetDrainPos(), _rbuf.GetUsedLen());
     }
+
+    void clear() {
+        _rbuf.Reuse();
+        _inputFields = NULL;
+        _currPath.clear();
+    }
 };
 
 }