use new input/output model in slime

31 files changed, 165 insertions, 642 deletions

diff --git a/vespalib/src/tests/slime/json_slime_benchmark.cpp b/vespalib/src/tests/slime/json_slime_benchmark.cpp
index ea6ea89375b..e818b2d4c34 100644
--- a/vespalib/src/tests/slime/json_slime_benchmark.cpp
+++ b/vespalib/src/tests/slime/json_slime_benchmark.cpp
@@ -9,7 +9,7 @@
 using namespace vespalib::slime::convenience;
 
 std::string make_json(const Slime &slime, bool compact) {
-    vespalib::slime::SimpleBuffer buf;
+    vespalib::SimpleBuffer buf;
     vespalib::slime::JsonFormat::encode(slime, buf, compact);
     return buf.get().make_string();
 }
diff --git a/vespalib/src/tests/slime/slime_binary_format_test.cpp b/vespalib/src/tests/slime/slime_binary_format_test.cpp
index f35e0637a67..cafebf4fc8b 100644
--- a/vespalib/src/tests/slime/slime_binary_format_test.cpp
+++ b/vespalib/src/tests/slime/slime_binary_format_test.cpp
@@ -7,6 +7,7 @@
 using namespace vespalib::slime::convenience;
 using namespace vespalib::slime::binary_format;
 using namespace vespalib::slime;
+using namespace vespalib;
 
 //-----------------------------------------------------------------------------
 
@@ -63,15 +64,15 @@ void verify_cmpr_ulong(uint64_t value, SimpleBuffer expect) {
         }
     }
     { // use write API
-        BufferedOutput out(buf2);
+        OutputWriter out(buf2, 32);
         write_cmpr_ulong(out, value);
     }
     EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(buf1.get()));
     EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(buf2.get()));
     {
-        BufferedInput input(expect.get());
+        InputReader input(expect);
         EXPECT_EQUAL(value, read_cmpr_ulong(input));
-        EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(input.getConsumed()));
+        EXPECT_EQUAL(input.get_offset(), buf1.get().size);
         EXPECT_TRUE(!input.failed());
     }
 }
@@ -95,35 +96,35 @@ void verifyMultiEncode(const Slime & slime, const SimpleBuffer &expect) {
 
 namespace {
 template <typename T>
-void encodeBasic(BufferedOutput &out,
+void encodeBasic(OutputWriter &out,
                  const typename TypeTraits<T>::PassType &value);
 
 template <>
-void encodeBasic<BOOL>(BufferedOutput &out, const bool &value)
+void encodeBasic<BOOL>(OutputWriter &out, const bool &value)
 {
-    out.writeByte(encode_type_and_meta(BOOL::ID, value ? 1 : 0));
+    out.write(encode_type_and_meta(BOOL::ID, value ? 1 : 0));
 }
 
-template <> void encodeBasic<LONG>(BufferedOutput &out, const int64_t &value)
+template <> void encodeBasic<LONG>(OutputWriter &out, const int64_t &value)
 {
     write_type_and_bytes<false>(out, LONG::ID, encode_zigzag(value));
 }
 
-template <> void encodeBasic<DOUBLE>(BufferedOutput &out, const double &value)
+template <> void encodeBasic<DOUBLE>(OutputWriter &out, const double &value)
 {
     write_type_and_bytes<true>(out, DOUBLE::ID, encode_double(value));
 }
 
-template <> void encodeBasic<STRING>(BufferedOutput &out, const Memory &value)
+template <> void encodeBasic<STRING>(OutputWriter &out, const Memory &value)
 {
     write_type_and_size(out, STRING::ID, value.size);
-    out.writeBytes(value.data, value.size);
+    out.write(value.data, value.size);
 }
 
-template <> void encodeBasic<DATA>(BufferedOutput &out, const Memory &value)
+template <> void encodeBasic<DATA>(OutputWriter &out, const Memory &value)
 {
     write_type_and_size(out, DATA::ID, value.size);
-    out.writeBytes(value.data, value.size);
+    out.write(value.data, value.size);
 }
 } // namespace <unnamed>
 
@@ -167,7 +168,7 @@ void verifyBasic(const typename TypeTraits<T>::PassType &value) {
     SimpleBuffer expect;
     SimpleBuffer actual;
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 0); // num symbols
         encodeBasic<T>(out, value);
     }
@@ -288,121 +289,33 @@ TEST("testCmprUlong") {
     }
 }
 
-TEST("testWriteByte") {
-    SimpleBuffer buf;
-    {
-        BufferedOutput out(buf);
-        out.writeByte(0x55);
-    }
-    EXPECT_EQUAL(1u, buf.get().size);
-    EXPECT_EQUAL(0x55, buf.get().data[0]);
-    {
-        BufferedOutput out(buf);
-        out.writeByte(0x66);
-        out.writeByte(0x77);
-    }
-    EXPECT_EQUAL(3u, buf.get().size);
-    EXPECT_EQUAL(0x55, buf.get().data[0]);
-    EXPECT_EQUAL(0x66, buf.get().data[1]);
-    EXPECT_EQUAL(0x77, buf.get().data[2]);
-}
-
-TEST("testWriteBytes") {
-    SimpleBuffer buf;
-    {
-        BufferedOutput out(buf);
-        out.writeBytes(0, 0);
-    }
-    EXPECT_EQUAL(0u, buf.get().size);
-    {
-        BufferedOutput out(buf);
-        char tmp[] = { 0x55 };
-        out.writeBytes(tmp, 1);
-    }
-    EXPECT_EQUAL(1u, buf.get().size);
-    EXPECT_EQUAL(0x55, buf.get().data[0]);
-    {
-        BufferedOutput out(buf);
-        char tmp[] = { 0x66, 0x77 };
-        out.writeBytes(tmp, 2);
-    }
-    EXPECT_EQUAL(3u, buf.get().size);
-    EXPECT_EQUAL(0x55, buf.get().data[0]);
-    EXPECT_EQUAL(0x66, buf.get().data[1]);
-    EXPECT_EQUAL(0x77, buf.get().data[2]);
-}
-
-TEST("testReadByte") {
-    SimpleBuffer buf;
-    buf.add(0x11).add(0x22).add(0x33);
-    {
-        BufferedInput in(buf.get());
-        EXPECT_EQUAL(0u, in.getConsumed().size);
-        EXPECT_EQUAL(0x11, in.getByte());
-        EXPECT_EQUAL(1u, in.getConsumed().size);
-        EXPECT_EQUAL(0x22, in.getByte());
-        EXPECT_EQUAL(2u, in.getConsumed().size);
-        EXPECT_EQUAL(0x33, in.getByte());
-        EXPECT_EQUAL(3u, in.getConsumed().size);
-        EXPECT_TRUE(!in.failed());
-        EXPECT_EQUAL(0u, in.getOffending().size);
-        EXPECT_EQUAL(0x00, in.getByte());
-        EXPECT_TRUE(in.failed());
-        EXPECT_EQUAL(0u, in.getConsumed().size);
-        EXPECT_EQUAL(3u, in.getOffending().size);
-        EXPECT_EQUAL(0x00, in.getByte());
-        EXPECT_EQUAL(0x00, in.getByte());
-        EXPECT_EQUAL(0x00, in.getByte());
-    }
-}
-
-TEST("testReadBytes") {
-    SimpleBuffer buf;
-    buf.add('a').add('b').add('c');
-    {
-        BufferedInput in(buf.get());
-        EXPECT_EQUAL(0u, in.getConsumed().size);
-        EXPECT_EQUAL("ab", in.getBytes(2).make_string());
-        EXPECT_EQUAL(2u, in.getConsumed().size);
-        EXPECT_TRUE(!in.failed());
-        EXPECT_EQUAL(0u, in.getOffending().size);
-        EXPECT_EQUAL(0u, in.getBytes(2).size);
-        EXPECT_TRUE(in.failed());
-        EXPECT_EQUAL(0u, in.getConsumed().size);
-        EXPECT_EQUAL(3u, in.getOffending().size);
-        EXPECT_EQUAL(0u, in.getBytes(2).size);
-        EXPECT_EQUAL(0u, in.getBytes(2).size);
-        EXPECT_EQUAL(0u, in.getBytes(2).size);
-    }
-}
-
 TEST("testTypeAndSize") {
     for (uint32_t type = 0; type < TYPE_LIMIT; ++type) {
         for (uint32_t size = 0; size < 500; ++size) {
             SimpleBuffer expect;
             SimpleBuffer actual;
             {
-                BufferedOutput expect_out(expect);
+                OutputWriter expect_out(expect, 32);
                 if ((size + 1) < META_LIMIT) {
-                    expect_out.writeByte(encode_type_and_meta(type, size + 1));
+                    expect_out.write(encode_type_and_meta(type, size + 1));
                 } else {
-                    expect_out.writeByte(type);
+                    expect_out.write(type);
                     write_cmpr_ulong(expect_out, size);
                 }
             }
             {
-                BufferedOutput actual_out(actual);
+                OutputWriter actual_out(actual, 32);
                 write_type_and_size(actual_out, type, size);
             }
             EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(actual.get()));
             {
-                BufferedInput input(expect.get());
-                char byte = input.getByte();
+                InputReader input(expect);
+                char byte = input.read();
                 uint32_t decodedType = decode_type(byte);
                 uint64_t decodedSize = read_size(input, decode_meta(byte));
                 EXPECT_EQUAL(type, decodedType);
                 EXPECT_EQUAL(size, decodedSize);
-                EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(input.getConsumed()));
+                EXPECT_EQUAL(input.get_offset(), actual.get().size);
                 EXPECT_TRUE(!input.failed());
             }
         }
@@ -445,7 +358,7 @@ TEST("testTypeAndBytes") {
                     uint64_t bits = build_bits(type, n, pre,
                                                (hi != 0), expect);
                     {
-                        BufferedOutput out(actual);
+                        OutputWriter out(actual, 32);
                         if (hi != 0) {
                             write_type_and_bytes<true>(out, type, bits);
                         } else {
@@ -454,8 +367,8 @@ TEST("testTypeAndBytes") {
                     }
                     EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(actual.get()));
                     {
-                        BufferedInput input(expect.get());
-                        uint32_t size = decode_meta(input.getByte());
+                        InputReader input(expect);
+                        uint32_t size = decode_meta(input.read());
                         uint64_t decodedBits;
                         if (hi != 0) {
                             decodedBits = read_bytes<true>(input, size);
@@ -463,8 +376,7 @@ TEST("testTypeAndBytes") {
                             decodedBits = read_bytes<false>(input, size);
                         }
                         EXPECT_EQUAL(bits, decodedBits);
-                        EXPECT_EQUAL(MemCmp(expect.get()),
-                                   MemCmp(input.getConsumed()));
+                        EXPECT_EQUAL(input.get_offset(), actual.get().size);
                         EXPECT_TRUE(!input.failed());
                     }
                 }
@@ -478,9 +390,9 @@ TEST("testEmpty") {
     SimpleBuffer expect;
     SimpleBuffer actual;
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 0); // num symbols
-        out.writeByte(0);       // nix
+        out.write(0);       // nix
     }
     BinaryFormat::encode(slime, actual);
     EXPECT_EQUAL(MemCmp(expect.get()), MemCmp(actual.get()));
@@ -532,10 +444,10 @@ TEST("testArray") {
     c.addString(Memory("string"));
     c.addData(Memory("data"));
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 0); // num symbols
         write_type_and_size(out, ARRAY::ID, 6);
-        out.writeByte(0);
+        out.write(0);
         encodeBasic<BOOL>(out, true);
         encodeBasic<LONG>(out, 5);
         encodeBasic<DOUBLE>(out, 3.5);
@@ -559,23 +471,23 @@ TEST("testObject") {
     c.setString("e", Memory("string"));
     c.setData("f", Memory("data"));
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 6); // num symbols
         write_cmpr_ulong(out, 1);
-        out.writeBytes("a", 1); // 0
+        out.write("a", 1); // 0
         write_cmpr_ulong(out, 1);
-        out.writeBytes("b", 1); // 1
+        out.write("b", 1); // 1
         write_cmpr_ulong(out, 1);
-        out.writeBytes("c", 1); // 2
+        out.write("c", 1); // 2
         write_cmpr_ulong(out, 1);
-        out.writeBytes("d", 1); // 3
+        out.write("d", 1); // 3
         write_cmpr_ulong(out, 1);
-        out.writeBytes("e", 1); // 4
+        out.write("e", 1); // 4
         write_cmpr_ulong(out, 1);
-        out.writeBytes("f", 1); // 5
+        out.write("f", 1); // 5
         write_type_and_size(out, OBJECT::ID, 6);
         write_cmpr_ulong(out, 0);
-        out.writeByte(0);
+        out.write(0);
         write_cmpr_ulong(out, 1);
         encodeBasic<BOOL>(out, true);
         write_cmpr_ulong(out, 2);
@@ -611,14 +523,14 @@ TEST("testNesting") {
         }
     }
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 3);   // num symbols
         write_cmpr_ulong(out, 3);
-        out.writeBytes("bar", 3);    // 0
+        out.write("bar", 3);    // 0
         write_cmpr_ulong(out, 3);
-        out.writeBytes("foo", 3);    // 1
+        out.write("foo", 3);    // 1
         write_cmpr_ulong(out, 6);
-        out.writeBytes("answer", 6); // 2
+        out.write("answer", 6); // 2
         write_type_and_size(out, OBJECT::ID, 2);
         write_cmpr_ulong(out, 0);   // bar
         encodeBasic<LONG>(out, 10);
@@ -654,12 +566,12 @@ TEST("testSymbolReuse") {
         }
     }
     {
-        BufferedOutput out(expect);
+        OutputWriter out(expect, 32);
         write_cmpr_ulong(out, 2);   // num symbols
         write_cmpr_ulong(out, 3);
-        out.writeBytes("foo", 3); // 0
+        out.write("foo", 3); // 0
         write_cmpr_ulong(out, 3);
-        out.writeBytes("bar", 3); // 1
+        out.write("bar", 3); // 1
         write_type_and_size(out, ARRAY::ID, 2);
         write_type_and_size(out, OBJECT::ID, 2);
         write_cmpr_ulong(out, 0);   // foo
@@ -680,18 +592,18 @@ TEST("testSymbolReuse") {
 TEST("testOptionalDecodeOrder") {
     SimpleBuffer data;
     {
-        BufferedOutput out(data);
+        OutputWriter out(data, 32);
         write_cmpr_ulong(out, 5); // num symbols
         write_cmpr_ulong(out, 1);
-        out.writeBytes("d", 1); // 0
+        out.write("d", 1); // 0
         write_cmpr_ulong(out, 1);
-        out.writeBytes("e", 1); // 1
+        out.write("e", 1); // 1
         write_cmpr_ulong(out, 1);
-        out.writeBytes("f", 1); // 2
+        out.write("f", 1); // 2
         write_cmpr_ulong(out, 1);
-        out.writeBytes("b", 1); // 3
+        out.write("b", 1); // 3
         write_cmpr_ulong(out, 1);
-        out.writeBytes("c", 1); // 4
+        out.write("c", 1); // 4
         write_type_and_size(out, OBJECT::ID, 5);
         write_cmpr_ulong(out, 3); // b
         encodeBasic<BOOL>(out, true);
@@ -751,4 +663,11 @@ TEST("require that decode_into without symbol names work") {
     EXPECT_EQUAL(slime.get()[my_sym].asLong(), 100);
 }
 
+TEST("require that decode failure results in 0 return value") {
+    SimpleBuffer buf;
+    buf.add(char(0)); // empty symbol table, but no value
+    Slime slime;
+    EXPECT_EQUAL(BinaryFormat::decode(buf.get(), slime), 0u);
+}
+
 TEST_MAIN() { TEST_RUN_ALL(); }
diff --git a/vespalib/src/tests/slime/slime_json_format_test.cpp b/vespalib/src/tests/slime/slime_json_format_test.cpp
index c054cc5a428..c87f0d9d4af 100644
--- a/vespalib/src/tests/slime/slime_json_format_test.cpp
+++ b/vespalib/src/tests/slime/slime_json_format_test.cpp
@@ -8,7 +8,7 @@
 using namespace vespalib::slime::convenience;
 
 std::string make_json(const Slime &slime, bool compact) {
-    vespalib::slime::SimpleBuffer buf;
+    vespalib::SimpleBuffer buf;
     vespalib::slime::JsonFormat::encode(slime, buf, compact);
     return buf.get().make_string();
 }
@@ -325,23 +325,23 @@ TEST("decode whitespace") {
 }
 
 TEST("decode invalid input") {
-    EXPECT_FALSE(check_valid(""));
-    EXPECT_FALSE(check_valid("["));
-    EXPECT_FALSE(check_valid("{"));
-    EXPECT_FALSE(check_valid("]"));
-    EXPECT_FALSE(check_valid("}"));
-    EXPECT_FALSE(check_valid("{]"));
-    EXPECT_FALSE(check_valid("[}"));
-    EXPECT_FALSE(check_valid("+5"));
-    EXPECT_FALSE(check_valid("fals"));
-    EXPECT_FALSE(check_valid("tru"));
-    EXPECT_FALSE(check_valid("nul"));
-    EXPECT_FALSE(check_valid("bar"));
-    EXPECT_FALSE(check_valid("\"bar"));
-    EXPECT_FALSE(check_valid("bar\""));
-    EXPECT_FALSE(check_valid("'bar\""));
-    EXPECT_FALSE(check_valid("\"bar'"));
-    EXPECT_FALSE(check_valid("{\"foo"));
+    EXPECT_TRUE(!check_valid(""));
+    EXPECT_TRUE(!check_valid("["));
+    EXPECT_TRUE(!check_valid("{"));
+    EXPECT_TRUE(!check_valid("]"));
+    EXPECT_TRUE(!check_valid("}"));
+    EXPECT_TRUE(!check_valid("{]"));
+    EXPECT_TRUE(!check_valid("[}"));
+    EXPECT_TRUE(!check_valid("+5"));
+    EXPECT_TRUE(!check_valid("fals"));
+    EXPECT_TRUE(!check_valid("tru"));
+    EXPECT_TRUE(!check_valid("nul"));
+    EXPECT_TRUE(!check_valid("bar"));
+    EXPECT_TRUE(!check_valid("\"bar"));
+    EXPECT_TRUE(!check_valid("bar\""));
+    EXPECT_TRUE(!check_valid("'bar\""));
+    EXPECT_TRUE(!check_valid("\"bar'"));
+    EXPECT_TRUE(!check_valid("{\"foo"));
 }
 
 TEST("decode simplified form") {
diff --git a/vespalib/src/tests/slime/slime_test.cpp b/vespalib/src/tests/slime/slime_test.cpp
index efb864d9c72..9418a999cbb 100644
--- a/vespalib/src/tests/slime/slime_test.cpp
+++ b/vespalib/src/tests/slime/slime_test.cpp
@@ -268,7 +268,7 @@ TEST("slime toString produces human-readable JSON") {
     }
     std::string expect;
     {
-        vespalib::slime::SimpleBuffer buf;
+        vespalib::SimpleBuffer buf;
         vespalib::slime::JsonFormat::encode(slime, buf, false);
         expect = buf.get().make_string();
     }
diff --git a/vespalib/src/tests/slime/summary-feature-benchmark/summary-feature-benchmark.cpp b/vespalib/src/tests/slime/summary-feature-benchmark/summary-feature-benchmark.cpp
index ba95c1fef9c..5fd5d3be3e9 100644
--- a/vespalib/src/tests/slime/summary-feature-benchmark/summary-feature-benchmark.cpp
+++ b/vespalib/src/tests/slime/summary-feature-benchmark/summary-feature-benchmark.cpp
@@ -6,12 +6,17 @@
 using namespace vespalib;
 using namespace vespalib::slime::convenience;
 
-struct MyBuffer : public slime::Output {
+struct MyBuffer : public Output {
     std::vector<char> data;
     size_t            used;
     MyBuffer() : data(1024 * 1024), used(0) {}
-    virtual char *exchange(char *, size_t commit, size_t) {
-        return &data[used += commit];
+    WritableMemory reserve(size_t bytes) override {
+        assert(data.size() >= (used + bytes));
+        return WritableMemory(&data[used], data.size() - used);
+    }
+    Output &commit(size_t bytes) override {
+        used += bytes;
+        return *this;
     }
 };
 
diff --git a/vespalib/src/tests/slime/type_traits.h b/vespalib/src/tests/slime/type_traits.h
index 0af21629945..c16c0a68380 100644
--- a/vespalib/src/tests/slime/type_traits.h
+++ b/vespalib/src/tests/slime/type_traits.h
@@ -3,8 +3,7 @@
 #pragma once
 
 #include <vespa/vespalib/data/slime/type.h>
-#include <vespa/vespalib/data/slime/memory.h>
-#include <vespa/vespalib/data/slime/stored_memory.h>
+#include <vespa/vespalib/data/memory.h>
 
 namespace vespalib {
 namespace slime {
@@ -36,13 +35,11 @@ template<> struct TypeTraits<DOUBLE> {
 
 template<> struct TypeTraits<STRING> {
     typedef Memory PassType;
-    typedef StoredMemory StoreType;
     static const Memory unsetValue;
 };
 
 template<> struct TypeTraits<DATA> {
     typedef Memory PassType;
-    typedef StoredMemory StoreType;
     static const Memory unsetValue;
 };
 
diff --git a/vespalib/src/tests/trace/trace_serialization.cpp b/vespalib/src/tests/trace/trace_serialization.cpp
index a7896d43338..a146f4d0ae6 100644
--- a/vespalib/src/tests/trace/trace_serialization.cpp
+++ b/vespalib/src/tests/trace/trace_serialization.cpp
@@ -78,7 +78,7 @@ TEST("that a trace node with children can be deserialized") {
     bar.setLong("timestamp", 67);
     bar.setString("payload", "!");
 
-    vespalib::slime::SimpleBuffer buf;
+    vespalib::SimpleBuffer buf;
     vespalib::slime::JsonFormat::encode(slime, buf, false);
 
     SlimeTraceDeserializer deserializer(root);
diff --git a/vespalib/src/vespa/vespalib/data/slime/CMakeLists.txt b/vespalib/src/vespa/vespalib/data/slime/CMakeLists.txt
index e1749627ac5..5c662a2dd18 100644
--- a/vespalib/src/vespa/vespalib/data/slime/CMakeLists.txt
+++ b/vespalib/src/vespa/vespalib/data/slime/CMakeLists.txt
@@ -6,8 +6,6 @@ vespa_add_library(vespalib_vespalib_data_slime OBJECT
     basic_value.cpp
     basic_value_factory.cpp
     binary_format.cpp
-    buffered_input.cpp
-    buffered_output.cpp
     convenience.cpp
     cursor.cpp
     empty_value_factory.cpp
@@ -15,18 +13,14 @@ vespa_add_library(vespalib_vespalib_data_slime OBJECT
     inserter.cpp
     inspector.cpp
     json_format.cpp
-    memory.cpp
     named_symbol_inserter.cpp
     named_symbol_lookup.cpp
     nix_value.cpp
     object_traverser.cpp
     object_value.cpp
-    output.cpp
     resolved_symbol.cpp
     root_value.cpp
-    simple_buffer.cpp
     slime.cpp
-    stored_memory.cpp
     strfmt.cpp
     symbol.cpp
     symbol_inserter.cpp
diff --git a/vespalib/src/vespa/vespalib/data/slime/binary_format.cpp b/vespalib/src/vespa/vespalib/data/slime/binary_format.cpp
index be2089b4076..4588331124b 100644
--- a/vespalib/src/vespa/vespalib/data/slime/binary_format.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/binary_format.cpp
@@ -4,6 +4,7 @@
 #include "inserter.h"
 #include "slime.h"
 #include <vespa/vespalib/util/array.hpp>
+#include <vespa/vespalib/data/memory_input.h>
 
 namespace vespalib {
 namespace slime {
@@ -13,13 +14,13 @@ namespace binary_format {
 struct BinaryEncoder : public ArrayTraverser,
                        public ObjectSymbolTraverser
 {
-    BufferedOutput &out;
-    BinaryEncoder(BufferedOutput &out_in) : out(out_in) {}
+    OutputWriter &out;
+    BinaryEncoder(OutputWriter &out_in) : out(out_in) {}
     void encodeNix() {
-        out.writeByte(NIX::ID);
+        out.write(NIX::ID);
     }
     void encodeBool(bool value) {
-        out.writeByte(encode_type_and_meta(BOOL::ID, value ? 1 : 0));
+        out.write(encode_type_and_meta(BOOL::ID, value ? 1 : 0));
     }
     void encodeLong(int64_t value) {
         write_type_and_bytes<false>(out, LONG::ID, encode_zigzag(value));
@@ -29,11 +30,11 @@ struct BinaryEncoder : public ArrayTraverser,
     }
     void encodeString(const Memory &memory) {
         write_type_and_size(out, STRING::ID, memory.size);
-        out.writeBytes(memory.data, memory.size);
+        out.write(memory.data, memory.size);
     }
     void encodeData(const Memory &memory) {
         write_type_and_size(out, DATA::ID, memory.size);
-        out.writeBytes(memory.data, memory.size);
+        out.write(memory.data, memory.size);
     }
     void encodeArray(const Inspector &inspector) {
         ArrayTraverser &array_traverser = *this;
@@ -64,7 +65,7 @@ struct BinaryEncoder : public ArrayTraverser,
         for (size_t i = 0; i < numSymbols; ++i) {
             Memory image = slime.inspect(Symbol(i));
             write_cmpr_ulong(out, image.size);
-            out.writeBytes(image.data, image.size);
+            out.write(image.data, image.size);
         }
     }
     virtual void entry(size_t, const Inspector &inspector);
@@ -88,7 +89,7 @@ BinaryEncoder::field(const Symbol &symbol, const Inspector &inspector)
 
 struct DirectSymbols {
     void hint_symbol_count(size_t) {}
-    bool add_symbol(Symbol symbol, size_t i, BufferedInput &in) {
+    bool add_symbol(Symbol symbol, size_t i, InputReader &in) {
         if (symbol.getValue() != i) {
             in.fail("duplicate symbols in symbol table");
             return false;
@@ -103,7 +104,7 @@ struct MappedSymbols {
     void hint_symbol_count(size_t n) {
         symbol_mapping.reserve(n);
     }
-    bool add_symbol(Symbol symbol, size_t, BufferedInput &) {
+    bool add_symbol(Symbol symbol, size_t, InputReader &) {
         symbol_mapping.push_back(symbol);
         return true;
     }
@@ -122,13 +123,13 @@ struct SymbolHandler {
 template <bool remap_symbols>
 struct BinaryDecoder : SymbolHandler<remap_symbols>::type {
 
-    BufferedInput &in;
+    InputReader &in;
 
     using SymbolHandler<remap_symbols>::type::hint_symbol_count;
     using SymbolHandler<remap_symbols>::type::add_symbol;
     using SymbolHandler<remap_symbols>::type::map_symbol;
 
-    BinaryDecoder(BufferedInput &input) : in(input) {}
+    BinaryDecoder(InputReader &input) : in(input) {}
 
     Cursor &decodeNix(const Inserter &inserter) {
         return inserter.insertNix();
@@ -148,12 +149,12 @@ struct BinaryDecoder : SymbolHandler<remap_symbols>::type {
 
     Cursor &decodeString(const Inserter &inserter, uint32_t meta) {
         uint64_t size = read_size(in, meta);
-        return inserter.insertString(in.getBytes(size));
+        return inserter.insertString(in.read(size));
     }
 
     Cursor &decodeData(const Inserter &inserter, uint32_t meta) {
         uint64_t size = read_size(in, meta);
-        return inserter.insertData(in.getBytes(size));
+        return inserter.insertData(in.read(size));
     }
 
     Cursor &decodeArray(const Inserter &inserter, uint32_t meta);
@@ -175,7 +176,7 @@ struct BinaryDecoder : SymbolHandler<remap_symbols>::type {
     }
 
     void decodeValue(const Inserter &inserter) {
-        char byte = in.getByte();
+        char byte = in.read();
         Cursor &cursor = decodeValue(inserter,
                                     decode_type(byte),
                                     decode_meta(byte));
@@ -189,7 +190,7 @@ struct BinaryDecoder : SymbolHandler<remap_symbols>::type {
         hint_symbol_count(numSymbols);
         for (size_t i = 0; i < numSymbols; ++i) {
             uint64_t size = read_cmpr_ulong(in);
-            Memory image = in.getBytes(size);
+            Memory image = in.read(size);
             Symbol symbol = slime.insert(image);
             if (!add_symbol(symbol, i, in)) {
                 return;
@@ -227,16 +228,17 @@ BinaryDecoder<remap_symbols>::decodeObject(const Inserter &inserter, uint32_t me
 
 template <bool remap_symbols>
 size_t decode(const Memory &memory, Slime &slime, const Inserter &inserter) {
-    BufferedInput input(memory);
+    MemoryInput memory_input(memory);
+    InputReader input(memory_input);
     binary_format::BinaryDecoder<remap_symbols> decoder(input);
     decoder.decodeSymbolTable(slime);
     decoder.decodeValue(inserter);
     if (input.failed() && !remap_symbols) {
         slime.wrap("partial_result");
-        slime.get().setData("offending_input", input.getOffending());
-        slime.get().setString("error_message", input.getErrorMessage());
+        slime.get().setLong("offending_offset", input.get_offset());
+        slime.get().setString("error_message", input.get_error_message());
     }
-    return input.getConsumed().size;
+    return input.failed() ? 0 : input.get_offset();
 }
 
 } // namespace vespalib::slime::binary_format
@@ -244,7 +246,7 @@ size_t decode(const Memory &memory, Slime &slime, const Inserter &inserter) {
 void
 BinaryFormat::encode(const Slime &slime, Output &output)
 {
-    BufferedOutput out(output);
+    OutputWriter out(output, 8000);
     binary_format::BinaryEncoder encoder(out);
     encoder.encodeSymbolTable(slime);
     encoder.encodeValue(slime.get());
diff --git a/vespalib/src/vespa/vespalib/data/slime/binary_format.h b/vespalib/src/vespa/vespalib/data/slime/binary_format.h
index a49dc55a684..df6e32a0b22 100644
--- a/vespalib/src/vespa/vespalib/data/slime/binary_format.h
+++ b/vespalib/src/vespa/vespalib/data/slime/binary_format.h
@@ -2,10 +2,11 @@
 
 #pragma once
 
-#include "output.h"
+#include <string>
+#include <vespa/vespalib/data/output.h>
 #include "type.h"
-#include "buffered_input.h"
-#include "buffered_output.h"
+#include <vespa/vespalib/data/input_reader.h>
+#include <vespa/vespalib/data/output_writer.h>
 #include "inserter.h"
 
 namespace vespalib {
@@ -70,26 +71,26 @@ inline uint32_t encode_cmpr_ulong(char *out,
     return (pos - out);
 }
 
-inline void write_cmpr_ulong(BufferedOutput &out,
+inline void write_cmpr_ulong(OutputWriter &out,
                              uint64_t value)
 {
     out.commit(encode_cmpr_ulong(out.reserve(10), value));
 }
 
-inline uint64_t read_cmpr_ulong(BufferedInput &in)
+inline uint64_t read_cmpr_ulong(InputReader &in)
 {
-    uint64_t next = in.getByte();
+    uint64_t next = in.read();
     uint64_t value = (next & 0x7f);
     int shift = 7;
     while ((next & 0x80) != 0) {
-        next = in.getByte();
+        next = in.read();
         value |= ((next & 0x7f) << shift);
         shift += 7;
     }
     return value;
 }
 
-inline void write_type_and_size(BufferedOutput &out,
+inline void write_type_and_size(OutputWriter &out,
                                 uint32_t type, uint64_t size)
 {
     char *start = out.reserve(11); // max size
@@ -103,13 +104,13 @@ inline void write_type_and_size(BufferedOutput &out,
     out.commit(pos - start);
 }
 
-inline uint64_t read_size(BufferedInput &in, uint32_t meta)
+inline uint64_t read_size(InputReader &in, uint32_t meta)
 {
     return (meta == 0) ? read_cmpr_ulong(in) : (meta - 1);
 }
 
 template <bool top>
-inline void write_type_and_bytes(BufferedOutput &out,
+inline void write_type_and_bytes(OutputWriter &out,
                                  uint32_t type, uint64_t bits)
 {
     char *start = out.reserve(9); // max size
@@ -128,13 +129,13 @@ inline void write_type_and_bytes(BufferedOutput &out,
 }
 
 template <bool top>
-inline uint64_t read_bytes(BufferedInput &in,
+inline uint64_t read_bytes(InputReader &in,
                            uint32_t bytes)
 {
     uint64_t value = 0;
     int shift = top ? 56 : 0;
     for (uint32_t i = 0; i < bytes; ++i) {
-        uint64_t byte = in.getByte();
+        uint64_t byte = in.read();
         value |= ((byte & 0xff) << shift);
         if (top) {
             shift -= 8;
diff --git a/vespalib/src/vespa/vespalib/data/slime/buffered_input.cpp b/vespalib/src/vespa/vespalib/data/slime/buffered_input.cpp
deleted file mode 100644
index 279f3de9f7e..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/buffered_input.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "buffered_input.h"
-
-namespace vespalib {
-namespace slime {
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/buffered_input.h b/vespalib/src/vespa/vespalib/data/slime/buffered_input.h
deleted file mode 100644
index 5c7f8e1c86f..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/buffered_input.h
+++ /dev/null
@@ -1,80 +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 "memory.h"
-#include <assert.h>
-
-namespace vespalib {
-namespace slime {
-
-/**
- * A simple class tracking the consumption of input data. Also keeps
- * track of data underflow.
- **/
-class BufferedInput
-{
-private:
-    const char *_begin; // start of input
-    const char *_pos;   // current read position
-    const char *_end;   // end of input
-    const char *_fail;  // read position at failure
-    std::string _msg;   // error message of failure
-
-public:
-    explicit BufferedInput(const Memory &memory)
-        : _begin(memory.data), _pos(_begin), _end(_pos + memory.size),
-          _fail(0), _msg() {}
-
-    bool eof() const { return (_pos == _end); }
-
-    bool failed() const { return (_fail != 0); }
-
-    const std::string &getErrorMessage() const { return _msg; }
-
-    Memory getConsumed() const {
-        if (_fail != 0) {
-            return Memory();
-        }
-        return Memory(_begin, (_pos - _begin));
-    }
-
-    Memory getOffending() const {
-        if (_fail == 0) {
-            return Memory();
-        }
-        return Memory(_begin, (_fail - _begin));
-    }
-
-    void fail(const std::string &msg) {
-        if (_fail == 0) {
-            _fail = _pos;
-            _msg = msg;
-            _pos = _end;
-        }
-    }
-
-    char getByte() {
-        if (_pos == _end) {
-            fail("input buffer underflow");
-            return 0;
-        }
-        return *_pos++;
-    }
-
-    Memory getBytes(size_t n) {
-        if ((_pos + n) > _end) {
-            assert(_fail == 0 || _pos == _end);
-            _pos = _end;
-            fail("input buffer underflow");
-            return Memory();
-        }
-        Memory ret(_pos, n);
-        _pos += n;
-        return ret;
-    }
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/buffered_output.cpp b/vespalib/src/vespa/vespalib/data/slime/buffered_output.cpp
deleted file mode 100644
index 1f2d19737d9..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/buffered_output.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "buffered_output.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <assert.h>
-
-namespace vespalib {
-namespace slime {
-
-void
-BufferedOutput::printf(const char *fmt, ...)
-{
-    int space = 256;
-    char *p = reserve(space);
-    int size;
-    va_list ap;
-    va_start(ap, fmt);
-    size = vsnprintf(p, space, fmt, ap);
-    va_end(ap);
-    assert(size >= 0);
-    if (size >= space) {
-        space = size + 1;
-        p = reserve(space);
-        va_start(ap, fmt);
-        size = vsnprintf(p, space, fmt, ap);
-        va_end(ap);
-        assert((size + 1) == space);
-    }
-    commit(size);
-}
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/buffered_output.h b/vespalib/src/vespa/vespalib/data/slime/buffered_output.h
deleted file mode 100644
index c5c9ab5d17d..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/buffered_output.h
+++ /dev/null
@@ -1,71 +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 "output.h"
-#include <string.h>
-#include <algorithm>
-
-namespace vespalib {
-namespace slime {
-
-/**
- * Thin layer on top of the Output interface that supplies us with an
- * inlined API for efficient buffer handling.
- **/
-class BufferedOutput
-{
-private:
-    enum { CHUNK_SIZE = 8000 };
-
-    Output &_output;
-    char   *_start;
-    char   *_pos;
-    char   *_end;
-
-public:
-    BufferedOutput(Output &out)
-        : _output(out), _start(0), _pos(0), _end(0) {}
-
-    char *reserve(size_t bytes) {
-        if (__builtin_expect((size_t)(_end - _pos) < bytes, false)) {
-            size_t wantBytes = std::max(size_t(CHUNK_SIZE), bytes);
-            _start = _output.exchange(_start, _pos - _start, wantBytes);
-            _pos = _start;
-            _end = _start + wantBytes;
-        }
-        return _pos;
-    }
-
-    void commit(size_t bytes) {
-        _pos += bytes;
-    }
-
-    void writeByte(char value) {
-        reserve(1)[0] = value;
-        commit(1);
-    }
-
-    void writeBytes(const char *data, size_t size) {
-        char *p = reserve(size);
-        memcpy(p, data, size);
-        commit(size);
-    }
-
-    void printf(const char *fmt, ...)
-#ifdef __GNUC__
-        // Add printf format checks with gcc
-        __attribute__ ((format (printf,2,3)))
-#endif
-        ;
-
-    ~BufferedOutput() {
-        if (_pos != _start) {
-            _output.exchange(_start, _pos - _start, 0);
-        }
-    }
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/convenience.h b/vespalib/src/vespa/vespalib/data/slime/convenience.h
index 3d4e1947ab9..445f8c8c7d5 100644
--- a/vespalib/src/vespa/vespalib/data/slime/convenience.h
+++ b/vespalib/src/vespa/vespalib/data/slime/convenience.h
@@ -11,10 +11,10 @@
 namespace vespalib {
 
 class Slime;
+struct Memory;
 
 namespace slime {
 
-struct Memory;
 class Type;
 class Symbol;
 
@@ -23,7 +23,7 @@ namespace convenience {
 using ::vespalib::Slime;
 
 using ::vespalib::slime::Symbol;
-using ::vespalib::slime::Memory;
+using ::vespalib::Memory;
 using ::vespalib::slime::Cursor;
 using ::vespalib::slime::Inspector;
 using ::vespalib::slime::Type;
diff --git a/vespalib/src/vespa/vespalib/data/slime/inserter.h b/vespalib/src/vespa/vespalib/data/slime/inserter.h
index 76f6120ba55..18b2e900e39 100644
--- a/vespalib/src/vespa/vespalib/data/slime/inserter.h
+++ b/vespalib/src/vespa/vespalib/data/slime/inserter.h
@@ -3,7 +3,7 @@
 #pragma once
 
 #include "type.h"
-#include "memory.h"
+#include <vespa/vespalib/data/memory.h>
 #include "symbol.h"
 
 namespace vespalib {
diff --git a/vespalib/src/vespa/vespalib/data/slime/inspector.h b/vespalib/src/vespa/vespalib/data/slime/inspector.h
index 5f60222b052..228e14a981b 100644
--- a/vespalib/src/vespa/vespalib/data/slime/inspector.h
+++ b/vespalib/src/vespa/vespalib/data/slime/inspector.h
@@ -3,7 +3,7 @@
 #pragma once
 
 #include "type.h"
-#include "memory.h"
+#include <vespa/vespalib/data/memory.h>
 #include "symbol.h"
 
 namespace vespalib {
diff --git a/vespalib/src/vespa/vespalib/data/slime/json_format.cpp b/vespalib/src/vespa/vespalib/data/slime/json_format.cpp
index 04efc182637..d9bafbecdf2 100644
--- a/vespalib/src/vespa/vespalib/data/slime/json_format.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/json_format.cpp
@@ -7,6 +7,7 @@
 #include <errno.h>
 #include <cmath>
 #include <sstream>
+#include <vespa/vespalib/data/memory_input.h>
 
 namespace vespalib {
 namespace slime {
@@ -17,22 +18,22 @@ template <bool COMPACT>
 struct JsonEncoder : public ArrayTraverser,
                      public ObjectTraverser
 {
-    BufferedOutput &out;
+    OutputWriter &out;
     int level;
     bool head;
 
-    JsonEncoder(BufferedOutput &out_in)
+    JsonEncoder(OutputWriter &out_in)
         : out(out_in), level(0), head(true) {}
 
     void openScope(char c) {
-        out.writeByte(c);
+        out.write(c);
         ++level;
         head = true;
     }
 
     void separate(bool useComma) {
         if (!head && useComma) {
-            out.writeByte(',');
+            out.write(',');
         } else {
             head = false;
         }
@@ -44,17 +45,17 @@ struct JsonEncoder : public ArrayTraverser,
     void closeScope(char c) {
         --level;
         separate(false);
-        out.writeByte(c);
+        out.write(c);
     }
 
     void encodeNIX() {
-        out.writeBytes("null", 4);
+        out.write("null", 4);
     }
     void encodeBOOL(bool value) {
         if (value) {
-            out.writeBytes("true", 4);
+            out.write("true", 4);
         } else {
-            out.writeBytes("false", 5);
+            out.write("false", 5);
         }
     }
     void encodeLONG(int64_t value) {
@@ -62,7 +63,7 @@ struct JsonEncoder : public ArrayTraverser,
     }
     void encodeDOUBLE(double value) {
         if (std::isnan(value) || std::isinf(value)) {
-            out.writeBytes("null", 4);
+            out.write("null", 4);
         } else {
             out.printf("%g", value);
         }
@@ -138,11 +139,11 @@ struct JsonEncoder : public ArrayTraverser,
     virtual void entry(size_t idx, const Inspector &inspector);
     virtual void field(const Memory &symbol_name, const Inspector &inspector);
 
-    static void encode(const Inspector &inspector, BufferedOutput &out) {
+    static void encode(const Inspector &inspector, OutputWriter &out) {
         JsonEncoder<COMPACT> encoder(out);
         encoder.encodeValue(inspector);
         if (!COMPACT) {
-            out.writeByte('\n');
+            out.write('\n');
         }
     }
 };
@@ -162,9 +163,9 @@ JsonEncoder<COMPACT>::field(const Memory &symbol_name, const Inspector &inspecto
     separate(true);
     encodeSTRING(symbol_name);
     if (COMPACT) {
-        out.writeByte(':');
+        out.write(':');
     } else {
-        out.writeBytes(": ", 2);
+        out.write(": ", 2);
     }
     encodeValue(inspector);
 }
@@ -172,16 +173,16 @@ JsonEncoder<COMPACT>::field(const Memory &symbol_name, const Inspector &inspecto
 //-----------------------------------------------------------------------------
 
 struct JsonDecoder {
-    BufferedInput &in;
+    InputReader &in;
     char c;
     vespalib::string key;
     vespalib::string value;
 
-    JsonDecoder(BufferedInput &input) : in(input), c(in.getByte()), key(), value() {}
+    JsonDecoder(InputReader &input) : in(input), c(in.read()), key(), value() {}
 
     void next() {
-        if (!in.eof()) {
-            c = in.getByte();
+        if (in.obtain() > 0) {
+            c = in.read();
         } else {
             c = 0;
         }
@@ -467,7 +468,7 @@ insertNumber(Inserter &inserter, bool isLong, const vespalib::string & value, ch
 void
 JsonFormat::encode(const Inspector &inspector, Output &output, bool compact)
 {
-    BufferedOutput out(output);
+    OutputWriter out(output, 8000);
     if (compact) {
         JsonEncoder<true>::encode(inspector, out);
     } else {
@@ -484,15 +485,16 @@ JsonFormat::encode(const Slime &slime, Output &output, bool compact)
 size_t
 JsonFormat::decode(const Memory &memory, Slime &slime)
 {
-    BufferedInput input(memory);
+    MemoryInput memory_input(memory);
+    InputReader input(memory_input);
     JsonDecoder decoder(input);
     decoder.decodeValue(slime);
     if (input.failed()) {
         slime.wrap("partial_result");
-        slime.get().setString("offending_input", input.getOffending());
-        slime.get().setString("error_message", input.getErrorMessage());
+        slime.get().setLong("offending_offset", input.get_offset());
+        slime.get().setString("error_message", input.get_error_message());
     }
-    return input.getConsumed().size;
+    return input.failed() ? 0 : input.get_offset();
 }
 
 } // namespace vespalib::slime
diff --git a/vespalib/src/vespa/vespalib/data/slime/json_format.h b/vespalib/src/vespa/vespalib/data/slime/json_format.h
index bb23e168bd8..e334cd55546 100644
--- a/vespalib/src/vespa/vespalib/data/slime/json_format.h
+++ b/vespalib/src/vespa/vespalib/data/slime/json_format.h
@@ -2,10 +2,10 @@
 
 #pragma once
 
-#include "output.h"
+#include <vespa/vespalib/data/output.h>
 #include "type.h"
-#include "buffered_input.h"
-#include "buffered_output.h"
+#include <vespa/vespalib/data/input_reader.h>
+#include <vespa/vespalib/data/output_writer.h>
 
 namespace vespalib {
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/memory.cpp b/vespalib/src/vespa/vespalib/data/slime/memory.cpp
deleted file mode 100644
index 991f28a5865..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/memory.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "memory.h"
-#include "stored_memory.h"
-
-namespace vespalib {
-namespace slime {
-
-Memory::Memory(const StoredMemory &sm)
-    : data(sm._data),
-      size(sm._size)
-{
-}
-
-vespalib::string
-Memory::make_string() const
-{
-    return vespalib::string(data, size);
-}
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/memory.h b/vespalib/src/vespa/vespalib/data/slime/memory.h
deleted file mode 100644
index f89c6aa0730..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/memory.h
+++ /dev/null
@@ -1,44 +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/vespalib/stllike/string.h>
-#include <vespa/vespalib/stllike/hash_fun.h>
-
-namespace vespalib {
-namespace slime {
-
-class StoredMemory;
-
-/**
- * Simple wrapper used to reference a region of memory.
- **/
-struct Memory
-{
-    const char *data;
-    size_t      size;
-
-    Memory() : data(0), size(0) {}
-    Memory(const char *d, size_t s) : data(d), size(s) {}
-    Memory(const char *str) : data(str), size(strlen(str)) {}
-    Memory(const std::string &str)
-        : data(str.data()), size(str.size()) {}
-    Memory(const vespalib::string &str)
-        : data(str.data()), size(str.size()) {}
-    Memory(const stringref &str)
-        : data(str.data()), size(str.size()) {}
-    explicit Memory(const StoredMemory &sm);
-    vespalib::string make_string() const;
-    bool operator == (const Memory & rhs) const {
-        return (size == rhs.size) &&
-               ( (data == rhs.data) ||
-                 (memcmp(data, rhs.data, size) == 0) );
-    }
-    size_t hash() const {
-        return vespalib::hashValue(data, size);
-    }
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/output.cpp b/vespalib/src/vespa/vespalib/data/slime/output.cpp
deleted file mode 100644
index e7353dbe0ed..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/output.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "output.h"
-
-namespace vespalib {
-namespace slime {
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/output.h b/vespalib/src/vespa/vespalib/data/slime/output.h
deleted file mode 100644
index 26487faa85d..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/output.h
+++ /dev/null
@@ -1,20 +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 <stddef.h>
-
-namespace vespalib {
-namespace slime {
-
-/**
- * Interface used to interact with an external output buffer.
- **/
-struct Output {
-    virtual char *exchange(char *p, size_t commit, size_t reserve) = 0;
-    virtual ~Output() {}
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/simple_buffer.cpp b/vespalib/src/vespa/vespalib/data/slime/simple_buffer.cpp
deleted file mode 100644
index cbe6a579839..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/simple_buffer.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "simple_buffer.h"
-
-namespace vespalib {
-namespace slime {
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/simple_buffer.h b/vespalib/src/vespa/vespalib/data/slime/simple_buffer.h
deleted file mode 100644
index ccee73a9125..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/simple_buffer.h
+++ /dev/null
@@ -1,45 +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 "output.h"
-#include "memory.h"
-#include <vector>
-#include <assert.h>
-
-namespace vespalib {
-namespace slime {
-
-/**
- * Simple output buffer implementation.
- **/
-class SimpleBuffer : public Output
-{
-private:
-    std::vector<char> _data;
-    size_t            _used;
-
-public:
-    SimpleBuffer() : _data(), _used(0) {}
-    virtual char *exchange(char *p, size_t commit, size_t reserve) {
-        (void) p;
-        assert(p == &_data[_used] || commit == 0);
-        assert((_data.size() - _used) >= commit);
-        _used += commit;
-        _data.resize(_used + reserve, char(0x55));
-        return &_data[_used];
-    }
-    SimpleBuffer &add(char byte) {
-        assert(_data.size() == _used);
-        _data.push_back(byte);
-        ++_used;
-        return *this;
-    }
-    Memory get() const {
-        return Memory(&_data[0], _used);
-    }
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/slime.h b/vespalib/src/vespa/vespalib/data/slime/slime.h
index f938f6ca1c5..2ddefb061e6 100644
--- a/vespalib/src/vespa/vespalib/data/slime/slime.h
+++ b/vespalib/src/vespa/vespalib/data/slime/slime.h
@@ -7,8 +7,8 @@
 #include "basic_value.h"
 #include "basic_value_factory.h"
 #include "binary_format.h"
-#include "buffered_input.h"
-#include "buffered_output.h"
+#include <vespa/vespalib/data/input_reader.h>
+#include <vespa/vespalib/data/output_writer.h>
 #include "convenience.h"
 #include "cursor.h"
 #include "empty_value_factory.h"
@@ -16,17 +16,16 @@
 #include "inserter.h"
 #include "inspector.h"
 #include "json_format.h"
-#include "memory.h"
+#include <vespa/vespalib/data/memory.h>
 #include "named_symbol_inserter.h"
 #include "named_symbol_lookup.h"
 #include "nix_value.h"
 #include "object_traverser.h"
 #include "object_value.h"
-#include "output.h"
+#include <vespa/vespalib/data/output.h>
 #include "resolved_symbol.h"
 #include "root_value.h"
-#include "simple_buffer.h"
-#include "stored_memory.h"
+#include <vespa/vespalib/data/simple_buffer.h>
 #include "symbol.h"
 #include "symbol_inserter.h"
 #include "symbol_lookup.h"
@@ -57,7 +56,6 @@ private:
     typedef slime::RootValue     RootValue;
     typedef slime::Cursor        Cursor;
     typedef slime::Inspector     Inspector;
-    typedef slime::Memory        Memory;
 
     SymbolTable::UP              _names;
     Stash::UP                    _stash;
diff --git a/vespalib/src/vespa/vespalib/data/slime/stored_memory.cpp b/vespalib/src/vespa/vespalib/data/slime/stored_memory.cpp
deleted file mode 100644
index 86fcd929539..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/stored_memory.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "stored_memory.h"
-#include "memory.h"
-#include <stdlib.h>
-
-namespace vespalib {
-namespace slime {
-
-} // namespace vespalib::slime
-} // namespace vespalib
diff --git a/vespalib/src/vespa/vespalib/data/slime/stored_memory.h b/vespalib/src/vespa/vespalib/data/slime/stored_memory.h
deleted file mode 100644
index 7ca4967b220..00000000000
--- a/vespalib/src/vespa/vespalib/data/slime/stored_memory.h
+++ /dev/null
@@ -1,41 +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 <stddef.h>
-#include <vespa/vespalib/data/slime/memory.h>
-
-namespace vespalib {
-namespace slime {
-
-/**
- * Simple class used to store a region of memory.
- **/
-class StoredMemory
-{
-private:
-    friend struct Memory;
-    char  *_data;
-    size_t _size;
-
-    StoredMemory(const StoredMemory &);
-    StoredMemory &operator=(const StoredMemory &);
-public:
-    explicit StoredMemory(const Memory &mem) :
-        _data(0),
-        _size(mem.size)
-    {
-        if (__builtin_expect(_size > 0, true)) {
-            _data = static_cast<char*>(malloc(_size));
-            memcpy(_data, mem.data, _size);
-        }
-    }
-
-    ~StoredMemory() {
-        free(_data);
-    }
-};
-
-} // namespace vespalib::slime
-} // namespace vespalib
-
diff --git a/vespalib/src/vespa/vespalib/data/slime/symbol_table.h b/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
index e4cafa2b9d6..d9f6d4f3773 100644
--- a/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
+++ b/vespalib/src/vespa/vespalib/data/slime/symbol_table.h
@@ -3,7 +3,7 @@
 #pragma once
 
 #include "symbol.h"
-#include "memory.h"
+#include <vespa/vespalib/data/memory.h>
 #include <vespa/vespalib/stllike/hash_map.h>
 #include <vespa/vespalib/data/memorydatastore.h>
 
@@ -18,7 +18,7 @@ class SymbolTable
 private:
     struct hasher {
         size_t operator () (const Memory & lcm) const {
-            return lcm.hash();
+            return hashValue(lcm.data, lcm.size);
         }
     };
     using SymbolMap = hash_map<Memory, Symbol, hasher>;
diff --git a/vespalib/src/vespa/vespalib/data/slime/value.cpp b/vespalib/src/vespa/vespalib/data/slime/value.cpp
index 1b0b1fc01d4..3bc08c2bb3e 100644
--- a/vespalib/src/vespa/vespalib/data/slime/value.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/value.cpp
@@ -5,7 +5,7 @@
 #include "resolved_symbol.h"
 #include "empty_value_factory.h"
 #include "basic_value_factory.h"
-#include "simple_buffer.h"
+#include <vespa/vespalib/data/simple_buffer.h>
 #include "json_format.h"
 
 namespace vespalib {
@@ -75,7 +75,7 @@ Value::traverse(ObjectTraverser &) const {}
 vespalib::string
 Value::toString() const
 {
-    slime::SimpleBuffer buf;
+    SimpleBuffer buf;
     slime::JsonFormat::encode(*this, buf, false);
     return buf.get().make_string();
 }
diff --git a/vespalib/src/vespa/vespalib/trace/slime_trace_serializer.h b/vespalib/src/vespa/vespalib/trace/slime_trace_serializer.h
index 3b50f0878bf..802f0ab5fe9 100644
--- a/vespalib/src/vespa/vespalib/trace/slime_trace_serializer.h
+++ b/vespalib/src/vespa/vespalib/trace/slime_trace_serializer.h
@@ -18,9 +18,9 @@ class SlimeTraceSerializer : public TraceVisitor
 public:
     SlimeTraceSerializer(slime::Cursor & cursor);
     void visit(const TraceNode & node);
-    static const slime::Memory TIMESTAMP;
-    static const slime::Memory PAYLOAD;
-    static const slime::Memory CHILDREN;
+    static const Memory TIMESTAMP;
+    static const Memory PAYLOAD;
+    static const Memory CHILDREN;
 private:
     void addTimestamp(slime::Cursor & current, const TraceNode & node);
     void addPayload(slime::Cursor & current, const TraceNode & node);