Remove complicated option for slicing as it is not used anywhere.

10 files changed, 50 insertions, 406 deletions

diff --git a/document/src/tests/testbytebuffer.cpp b/document/src/tests/testbytebuffer.cpp
index 17807fb4ff5..feb3252a48c 100644
--- a/document/src/tests/testbytebuffer.cpp
+++ b/document/src/tests/testbytebuffer.cpp
@@ -134,78 +134,6 @@ TEST(ByteBuffer_Test, test_copy_constructor)
     }
 }
 
-TEST(ByteBuffer_Test, test_slice)
-{
-    ByteBuffer* newBuf=ByteBuffer::copyBuffer("hei der",8);
-
-    ByteBuffer* slice = new ByteBuffer;
-    slice->sliceFrom(*newBuf, 0,newBuf->getLength());
-    delete newBuf;
-    newBuf = NULL;
-
-    EXPECT_TRUE(strcmp(slice->getBufferAtPos(),"hei der")==0);
-
-    ByteBuffer* slice2 = new ByteBuffer;
-    slice2->sliceFrom(*slice, 4, slice->getLength());
-    delete slice;
-    slice = NULL;
-
-    EXPECT_TRUE(strcmp(slice2->getBufferAtPos(),"der")==0);
-    EXPECT_TRUE(strcmp(slice2->getBuffer(),"hei der")==0);
-    delete slice2;
-    slice2 = NULL;
-
-    ByteBuffer* newBuf2=new ByteBuffer("hei der", 8);
-    ByteBuffer* slice3=new ByteBuffer;
-    ByteBuffer* slice4=new ByteBuffer;
-
-    slice3->sliceFrom(*newBuf2, 4, newBuf2->getLength());
-    slice4->sliceFrom(*newBuf2, 0, newBuf2->getLength());
-    delete newBuf2;
-    newBuf2 = NULL;
-
-    EXPECT_TRUE(strcmp(slice3->getBufferAtPos(),"der")==0);
-    EXPECT_TRUE(strcmp(slice4->getBuffer(),"hei der")==0);
-
-    delete slice3;
-    slice3 = NULL;
-
-    EXPECT_TRUE(strcmp(slice4->getBuffer(),"hei der")==0);
-
-    delete slice4;
-    slice4 = NULL;
-}
-
-TEST(ByteBuffer_Test, test_slice2)
-{
-    ByteBuffer* newBuf=ByteBuffer::copyBuffer("hei der",8);
-
-    ByteBuffer slice;
-    slice.sliceFrom(*newBuf, 0, newBuf->getLength());
-
-    delete newBuf;
-    newBuf = NULL;
-
-    EXPECT_TRUE(strcmp(slice.getBufferAtPos(),"hei der")==0);
-
-    ByteBuffer slice2;
-    slice2.sliceFrom(slice, 4, slice.getLength());
-
-    EXPECT_TRUE(strcmp(slice2.getBufferAtPos(),"der")==0);
-    EXPECT_TRUE(strcmp(slice2.getBuffer(),"hei der")==0);
-
-    ByteBuffer* newBuf2=new ByteBuffer("hei der", 8);
-
-    slice.sliceFrom(*newBuf2, 4, newBuf2->getLength());
-    slice2.sliceFrom(*newBuf2, 0, newBuf2->getLength());
-    delete newBuf2;
-    newBuf2 = NULL;
-
-    EXPECT_TRUE(strcmp(slice.getBufferAtPos(),"der")==0);
-    EXPECT_TRUE(strcmp(slice2.getBuffer(),"hei der")==0);
-}
-
-
 TEST(ByteBuffer_Test, test_putGetFlip)
 {
     ByteBuffer* newBuf=new ByteBuffer(100);
diff --git a/document/src/vespa/document/fieldvalue/serializablearray.cpp b/document/src/vespa/document/fieldvalue/serializablearray.cpp
index 5dfd8eff891..ff0fe3dbdf0 100644
--- a/document/src/vespa/document/fieldvalue/serializablearray.cpp
+++ b/document/src/vespa/document/fieldvalue/serializablearray.cpp
@@ -34,6 +34,22 @@ SerializableArray::SerializableArray()
 {
 }
 
+SerializableArray::SerializableArray(EntryMap entries, ByteBuffer::UP buffer,
+                                     CompressionConfig::Type comp_type,uint32_t uncompressed_length)
+    : _entries(std::move(entries)),
+      _owned(),
+      _serializedCompression(comp_type)
+{
+
+    if (CompressionConfig::isCompressed(_serializedCompression)) {
+        _compSerData = std::move(buffer);
+        _uncompressedLength = uncompressed_length;
+    } else {
+        _uncompressedLength = buffer->getRemaining();
+        _uncompSerData = std::move(buffer);
+    }
+}
+
 serializablearray::BufferMap & ensure(std::unique_ptr<serializablearray::BufferMap> & owned) {
     if (!owned) {
         owned = std::make_unique<serializablearray::BufferMap>();
@@ -45,8 +61,8 @@ SerializableArray::SerializableArray(const SerializableArray& other)
     : Cloneable(),
       _entries(other._entries),
       _owned(),
-      _uncompSerData(other._uncompSerData.get() ? new ByteBuffer(*other._uncompSerData) : NULL),
-      _compSerData(other._compSerData.get() ? new ByteBuffer(*other._compSerData) : NULL),
+      _uncompSerData(other._uncompSerData.get() ? new ByteBuffer(*other._uncompSerData) : nullptr),
+      _compSerData(other._compSerData.get() ? new ByteBuffer(*other._compSerData) : nullptr),
       _serializedCompression(other._serializedCompression),
       _uncompressedLength(other._uncompressedLength)
 {
@@ -86,9 +102,7 @@ void SerializableArray::clear()
     _uncompressedLength = 0;
 }
 
-SerializableArray::~SerializableArray()
-{
-}
+SerializableArray::~SerializableArray() = default;
 
 void
 SerializableArray::invalidate()
@@ -102,7 +116,7 @@ SerializableArray::set(int id, ByteBuffer::UP buffer)
     maybeDecompress();
     Entry e(id, buffer->getRemaining(), buffer->getBuffer());
     ensure(_owned)[id] = std::move(buffer);
-    EntryMap::iterator it = find(id);
+    auto it = find(id);
     if (it == _entries.end()) {
         _entries.push_back(e);
     } else {
@@ -139,7 +153,7 @@ SerializableArray::get(int id) const
 {
     vespalib::ConstBufferRef buf;
     if ( !maybeDecompressAndCatch() ) {
-        EntryMap::const_iterator found = find(id);
+        auto found = find(id);
 
         if (found != _entries.end()) {
             const Entry& entry = *found;
@@ -168,7 +182,7 @@ void
 SerializableArray::clear(int id)
 {
     maybeDecompress();
-    EntryMap::iterator it = find(id);
+    auto it  = find(id);
     if (it != _entries.end()) {
         _entries.erase(it);
         if (_owned) {
@@ -221,24 +235,6 @@ SerializableArray::deCompress() // throw (DeserializeException)
     }
 }
 
-void SerializableArray::assign(EntryMap & entries,
-                               ByteBuffer::UP buffer,
-                               CompressionConfig::Type comp_type,
-                               uint32_t uncompressed_length)
-{
-    _serializedCompression = comp_type;
-
-    _entries.clear();
-    _entries.swap(entries);
-    if (CompressionConfig::isCompressed(_serializedCompression)) {
-        _compSerData.reset(buffer.release());
-        _uncompressedLength = uncompressed_length;
-    } else {
-        _uncompressedLength = buffer->getRemaining();
-        _uncompSerData.reset(buffer.release());
-    }
-}
-
 vespalib::compression::CompressionInfo
 SerializableArray::getCompressionInfo() const {
     return CompressionInfo(_uncompressedLength, _compSerData->getRemaining());
diff --git a/document/src/vespa/document/fieldvalue/serializablearray.h b/document/src/vespa/document/fieldvalue/serializablearray.h
index 1e2bf5706bf..7ee09f592b2 100644
--- a/document/src/vespa/document/fieldvalue/serializablearray.h
+++ b/document/src/vespa/document/fieldvalue/serializablearray.h
@@ -110,7 +110,9 @@ public:
     using CompressionInfo = vespalib::compression::CompressionInfo;
 
     SerializableArray();
-    virtual ~SerializableArray();
+    SerializableArray(EntryMap entries, ByteBufferUP buffer,
+                      CompressionConfig::Type comp_type, uint32_t uncompressed_length);
+    ~SerializableArray() override;
 
     void swap(SerializableArray& other);
 
@@ -140,9 +142,6 @@ public:
     /** @return Returns true if the given ID is Set in the array. */
     bool has(int id) const;
 
-    /** @return Number of elements in array */
-    bool hasAnyElems() const { return !_entries.empty(); }
-
     /**
      * clears an attribute.
      *
@@ -156,16 +155,6 @@ public:
     CompressionConfig::Type getCompression() const { return _serializedCompression; }
     CompressionInfo getCompressionInfo() const;
 
-    /**
-     * Sets the serialized data that is the basis for this object's
-     * content. This is used by deserialization. Any existing entries
-     * are cleared.
-     */
-    void assign(EntryMap &entries,
-                ByteBufferUP buffer,
-                CompressionConfig::Type comp_type,
-                uint32_t uncompressed_length);
-
     bool empty() const { return _entries.empty(); }
 
     const ByteBuffer* getSerializedBuffer() const {
diff --git a/document/src/vespa/document/fieldvalue/structfieldvalue.cpp b/document/src/vespa/document/fieldvalue/structfieldvalue.cpp
index a011f9d8949..1d74e99208a 100644
--- a/document/src/vespa/document/fieldvalue/structfieldvalue.cpp
+++ b/document/src/vespa/document/fieldvalue/structfieldvalue.cpp
@@ -81,13 +81,11 @@ StructFieldValue::lazyDeserialize(const FixedTypeRepo &repo,
     _doc_type = &repo.getDocumentType();
     _version = version;
 
-    _chunks.push_back(std::make_unique<SerializableArray>());
-    _chunks.back().assign(fm, std::move(buffer), comp_type, uncompressed_length);
+    _chunks.push_back(std::make_unique<SerializableArray>(std::move(fm), std::move(buffer), comp_type, uncompressed_length));
     _hasChanged = false;
 }
 
-bool StructFieldValue::serializeField(int field_id, uint16_t version,
-                                      FieldValueWriter &writer) const {
+bool StructFieldValue::serializeField(int field_id, uint16_t version, FieldValueWriter &writer) const {
     if (version == _version) {
         for (int i = _chunks.size() - 1; i >= 0; --i) {
             vespalib::ConstBufferRef buf = _chunks[i].get(field_id);
diff --git a/document/src/vespa/document/util/bytebuffer.cpp b/document/src/vespa/document/util/bytebuffer.cpp
index ccbc2bc7790..1b586a448cf 100644
--- a/document/src/vespa/document/util/bytebuffer.cpp
+++ b/document/src/vespa/document/util/bytebuffer.cpp
@@ -12,14 +12,6 @@
 #include <sstream>
 #include <arpa/inet.h>
 
-#define LOG_DEBUG1(a)
-// Enable this macros instead to see what bytebuffer calls come
-//#define LOG_DEBUG1(a) std::cerr << "ByteBuffer(" << ((void*) this) << " " << a << ")\n";
-
-#define LOG_DEBUG2(a,b) LOG_DEBUG1(vespalib::make_string(a,b));
-#define LOG_DEBUG3(a,b,c) LOG_DEBUG1(vespalib::make_string(a,b,c));
-#define LOG_DEBUG4(a,b,c,d) LOG_DEBUG1(vespalib::make_string(a,b,c,d));
-
 using vespalib::alloc::Alloc;
 
 namespace document {
@@ -46,15 +38,13 @@ InputOutOfRangeException::InputOutOfRangeException(
 }
 
 ByteBuffer::ByteBuffer() :
-      _buffer(NULL),
+      _buffer(nullptr),
       _len(0),
       _pos(0),
       _limit(0),
-      _bufHolder(NULL),
       _ownedBuffer()
 {
-    set(NULL, 0);
-    LOG_DEBUG1("Created empty bytebuffer");
+    set(nullptr, 0);
 }
 
 ByteBuffer::ByteBuffer(size_t len) :
@@ -63,11 +53,10 @@ ByteBuffer::ByteBuffer(size_t len) :
 }
 
 ByteBuffer::ByteBuffer(const char* buffer, size_t len) :
-      _buffer(NULL),
+      _buffer(nullptr),
       _len(0),
       _pos(0),
       _limit(0),
-      _bufHolder(NULL),
       _ownedBuffer()
 {
     set(buffer, len);
@@ -78,33 +67,17 @@ ByteBuffer::ByteBuffer(Alloc buffer, size_t len) :
       _len(len),
       _pos(0),
       _limit(len),
-      _bufHolder(NULL),
       _ownedBuffer(std::move(buffer))
 {
 }
 
-ByteBuffer::ByteBuffer(BufferHolder* buf, size_t pos, size_t len, size_t limit) :
-      _buffer(NULL),
-      _len(0),
-      _pos(0),
-      _limit(0),
-      _bufHolder(NULL),
-      _ownedBuffer()
-{
-    set(buf, pos, len, limit);
-    LOG_DEBUG3("Created copy of byte buffer of length %" PRIu64 " with "
-               "limit %" PRIu64 ".", len, limit);
-}
-
 ByteBuffer::ByteBuffer(const ByteBuffer& bb) :
       _buffer(0),
       _len(0),
       _pos(0),
       _limit(0),
-      _bufHolder(NULL),
       _ownedBuffer()
 {
-    LOG_DEBUG1("Created empty byte buffer to assign to.");
     *this = bb;
 }
 
@@ -121,99 +94,17 @@ ByteBuffer& ByteBuffer::operator=(const ByteBuffer & org)
         _len = org._len;
         _pos = org._pos;
         _limit = org._limit;
-        LOG_DEBUG4("Assignment created new buffer of size %" PRIu64 " at pos "
-                   "%" PRIu64 " with limit %" PRIu64 ".",
-                   _len, _pos, _limit);
     }
     return *this;
 }
 
-void
-ByteBuffer::set(BufferHolder* buf, size_t pos, size_t len, size_t limit)
-{
-    cleanUp();
-    _bufHolder = buf;
-    _bufHolder->addRef();
-    _buffer = static_cast<char *>(_bufHolder->_buffer.get());
-    _pos=pos;
-    _len=len;
-    _limit=limit;
-    LOG_DEBUG4("set() created new buffer of size %" PRIu64 " at pos "
-               "%" PRIu64 " with limit %" PRIu64 ".",
-               _len, _pos, _limit);
-}
-
-ByteBuffer::~ByteBuffer()
-{
-    if (_bufHolder) {
-        _bufHolder->subRef();
-    }
-}
-
-std::unique_ptr<ByteBuffer>
-ByteBuffer::sliceCopy() const
-{
-    ByteBuffer* buf = new ByteBuffer;
-    buf->sliceFrom(*this, _pos, _limit);
-
-    LOG_DEBUG3("Created slice at pos %" PRIu64 " with limit %" PRIu64 ".",
-               _pos, _limit);
-    return std::unique_ptr<ByteBuffer>(buf);
-}
+ByteBuffer::~ByteBuffer() = default;
 
 void ByteBuffer::throwOutOfBounds(size_t want, size_t has)
 {
-    LOG_DEBUG1("Throwing out of bounds exception");
     throw BufferOutOfBoundsException(want, has, VESPA_STRLOC);
 }
 
-void
-ByteBuffer::sliceFrom(const ByteBuffer& buf, size_t from, size_t to) // throw (BufferOutOfBoundsException)
-{
-    LOG_DEBUG3("Created slice from buffer from %" PRIu64 " to %" PRIu64 ".",
-               from, to);
-    if (from > buf._len) {
-        throwOutOfBounds(from, buf._len);
-    } else if (to > buf._len) {
-        throwOutOfBounds(to, buf._len);
-    } else if (to < from) {
-        throwOutOfBounds(to, from);
-    } else {
-
-        if (!buf._buffer) {
-            clear();
-            return;
-        }
-
-        // Slicing from someone that doesn't own their buffer, must make own copy.
-        if (( buf._ownedBuffer.get() == NULL ) && (buf._bufHolder == NULL)) {
-            cleanUp();
-            Alloc::alloc(to-from + 1).swap(_ownedBuffer);
-            _buffer = static_cast<char *>(_ownedBuffer.get());
-            memcpy(_buffer, buf._buffer + from, to-from);
-            _buffer[to-from] = 0;
-            _pos = 0;
-            _len = _limit = to-from;
-            return;
-        }
-
-        // Slicing from someone that owns, but hasn't made a reference counter yet.
-        if (!buf._bufHolder) {
-            buf._bufHolder=new BufferHolder(std::move(const_cast<Alloc &>(buf._ownedBuffer)));
-        }
-
-        // Slicing from refcounter.
-        cleanUp();
-
-        _bufHolder = buf._bufHolder;
-        _bufHolder->addRef();
-        _buffer = static_cast<char *>(_bufHolder->_buffer.get());
-        _pos=from;
-        _len=to;
-        _limit=to;
-    }
-}
-
 ByteBuffer* ByteBuffer::copyBuffer(const char* buffer, size_t len)
 {
     if (buffer && len) {
@@ -222,15 +113,13 @@ ByteBuffer* ByteBuffer::copyBuffer(const char* buffer, size_t len)
         static_cast<char *>(newBuf.get())[len] = 0;
         return new ByteBuffer(std::move(newBuf), len);
     } else {
-        return NULL;
+        return nullptr;
     }
 }
 
 void
 ByteBuffer::setPos(size_t pos) // throw (BufferOutOfBoundsException)
 {
-    LOG_DEBUG3("Setting pos to be %" PRIu64 ", limit is %" PRIu64 ".",
-               pos, _limit);
     if (pos>_limit) {
         throwOutOfBounds(pos, _limit);
     } else {
@@ -241,7 +130,6 @@ ByteBuffer::setPos(size_t pos) // throw (BufferOutOfBoundsException)
 void
 ByteBuffer::setLimit(size_t limit) // throw (BufferOutOfBoundsException)
 {
-    LOG_DEBUG3("Setting limit to %" PRIu64 ", (size is %" PRIu64 ").", limit, _len);
     if (limit>_len) {
         throwOutOfBounds(limit, _len);
     } else {
@@ -249,29 +137,8 @@ ByteBuffer::setLimit(size_t limit) // throw (BufferOutOfBoundsException)
     }
 }
 
-
-ByteBuffer::BufferHolder::BufferHolder(Alloc buffer)
-    : _buffer(std::move(buffer))
-{
-}
-
-ByteBuffer::BufferHolder::~BufferHolder() = default;
-void ByteBuffer::dump() const
-{
-    fprintf(stderr, "ByteBuffer: Length %lu, Pos %lu, Limit %lu\n",
-            _len, _pos, _limit);
-    for (size_t i=0; i<_len; i++) {
-        if (_buffer[i]>32 && _buffer[i]<126) {
-            fprintf(stderr, "%c", _buffer[i]);
-        } else {
-            fprintf(stderr, "[%d]",_buffer[i]);
-        }
-    }
-}
-
 void ByteBuffer::incPos(size_t pos)
 {
-    LOG_DEBUG2("incPos(%" PRIu64 ")", pos);
     if (_pos + pos > _limit) {
         throwOutOfBounds(_pos + pos, _limit);
     } else {
@@ -283,7 +150,6 @@ void ByteBuffer::incPos(size_t pos)
 }
 
 void ByteBuffer::getNumeric(uint8_t & v) {
-    LOG_DEBUG2("getNumeric8(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -293,7 +159,6 @@ void ByteBuffer::getNumeric(uint8_t & v) {
 }
 
 void ByteBuffer::putNumeric(uint8_t v) {
-    LOG_DEBUG2("putNumeric8(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -330,7 +195,6 @@ size_t ByteBuffer::forceValgrindPos2Lim() const
 
 
 void ByteBuffer::getNumericNetwork(int16_t & v) {
-    LOG_DEBUG2("getNumericNetwork16(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -340,18 +204,7 @@ void ByteBuffer::getNumericNetwork(int16_t & v) {
     }
 }
 
-void ByteBuffer::getNumeric(int16_t & v) {
-    LOG_DEBUG2("getNumeric16(%d)", (int) v);
-    if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
-        throwOutOfBounds(getRemaining(), sizeof(v));
-    } else {
-        v = *(int16_t *) (void *) getBufferAtPos();
-        incPosNoCheck(sizeof(v));
-    }
-}
-
 void ByteBuffer::putNumericNetwork(int16_t v) {
-    LOG_DEBUG2("putNumericNetwork16(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -361,18 +214,7 @@ void ByteBuffer::putNumericNetwork(int16_t v) {
     }
 }
 
-void ByteBuffer::putNumeric(int16_t v) {
-    LOG_DEBUG2("putNumeric16(%d)", (int) v);
-    if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
-        throwOutOfBounds(getRemaining(), sizeof(v));
-    } else {
-        *(int16_t *) (void *) getBufferAtPos() = v;
-        incPosNoCheck(sizeof(v));
-    }
-}
-
 void ByteBuffer::getNumericNetwork(int32_t & v) {
-    LOG_DEBUG2("getNumericNetwork32(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -383,7 +225,6 @@ void ByteBuffer::getNumericNetwork(int32_t & v) {
 }
 
 void ByteBuffer::getNumeric(int32_t & v) {
-    LOG_DEBUG2("getNumeric32(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -394,7 +235,6 @@ void ByteBuffer::getNumeric(int32_t & v) {
 
 
 void ByteBuffer::putNumericNetwork(int32_t v) {
-    LOG_DEBUG2("putNumericNetwork32(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -405,7 +245,6 @@ void ByteBuffer::putNumericNetwork(int32_t v) {
 }
 
 void ByteBuffer::putNumeric(int32_t v) {
-    LOG_DEBUG2("putNumeric32(%d)", (int) v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -414,17 +253,7 @@ void ByteBuffer::putNumeric(int32_t v) {
     }
 }
 
-void ByteBuffer::getNumericNetwork(float & v) {
-    LOG_DEBUG2("getNumericNetworkFloat(%f)", v);
-    // XXX depends on sizeof(float) == sizeof(uint32_t) == 4
-    // and endianness same for float and ints
-    int32_t val;
-    getIntNetwork(val);
-    memcpy(&v, &val, sizeof(v));
-}
-
 void ByteBuffer::getNumeric(float & v) {
-    LOG_DEBUG2("getNumericFloat(%f)", v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -433,26 +262,7 @@ void ByteBuffer::getNumeric(float & v) {
     }
 }
 
-void ByteBuffer::putNumericNetwork(float v) {
-    LOG_DEBUG2("putNumericNetworkFloat(%f)", v);
-    // XXX depends on sizeof(float) == sizeof(int32_t) == 4
-    // and endianness same for float and ints
-    int32_t val;
-    memcpy(&val, &v, sizeof(val));
-    putIntNetwork(val);
-}
-
-void ByteBuffer::putNumeric(float v) {
-    LOG_DEBUG2("putNumericFloat(%f)", v);
-    if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
-        throwOutOfBounds(getRemaining(), sizeof(v));
-    } else {
-        *(float *) (void *) getBufferAtPos() = v;
-        incPosNoCheck(sizeof(v));
-    }
-}
 void ByteBuffer::getNumeric(int64_t& v) {
-    LOG_DEBUG2("getNumeric64(%" PRId64 ")", v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -460,17 +270,8 @@ void ByteBuffer::getNumeric(int64_t& v) {
         incPosNoCheck(sizeof(v));
     }
 }
-void ByteBuffer::putNumeric(int64_t v) {
-    LOG_DEBUG2("putNumeric64(%" PRId64 ")", v);
-    if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
-        throwOutOfBounds(getRemaining(), sizeof(v));
-    } else {
-        *(int64_t *) (void *) getBufferAtPos() = v;
-        incPosNoCheck(sizeof(v));
-    }
-}
+
 void ByteBuffer::getNumeric(double& v) {
-    LOG_DEBUG2("getNumericDouble(%f)", v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -479,7 +280,6 @@ void ByteBuffer::getNumeric(double& v) {
     }
 }
 void ByteBuffer::putNumeric(double v) {
-    LOG_DEBUG2("putNumericDouble(%f)", v);
     if (__builtin_expect(getRemaining() < sizeof(v), 0)) {
         throwOutOfBounds(getRemaining(), sizeof(v));
     } else {
@@ -489,24 +289,19 @@ void ByteBuffer::putNumeric(double v) {
 }
 
 void ByteBuffer::getNumericNetwork(double & v) {
-    LOG_DEBUG2("getNumericNetworkDouble(%f)", v);
     getDoubleLongNetwork(v);
 }
 void ByteBuffer::putNumericNetwork(int64_t v) {
-    LOG_DEBUG2("putNumericNetwork64(%" PRId64 ")", v);
     putDoubleLongNetwork(v);
 }
 void ByteBuffer::putNumericNetwork(double v) {
-    LOG_DEBUG2("putNumericNetworkDouble(%f)", v);
     putDoubleLongNetwork(v);
 }
 void ByteBuffer::getNumericNetwork(int64_t & v) {
-    LOG_DEBUG2("getNumericNetwork64(%" PRId64 ")", v);
     getDoubleLongNetwork(v);
 }
 
 void ByteBuffer::putInt2_4_8Bytes(int64_t number, size_t len) {
-    LOG_DEBUG3("putInt2_4_8(%" PRId64 ", %" PRIu64 ")", number, len);
     if (number < 0ll) {
         throw InputOutOfRangeException(vespalib::make_string(
                     "Cannot encode negative number."), VESPA_STRLOC);
@@ -542,7 +337,6 @@ void ByteBuffer::putInt2_4_8Bytes(int64_t number, size_t len) {
 }
 
 void ByteBuffer::getInt2_4_8Bytes(int64_t & v) {
-    LOG_DEBUG2("getInt2_4_8(%" PRId64 ")", v);
     if (getRemaining() >= 2) {
         uint8_t flagByte = peekByte();
 
@@ -588,7 +382,6 @@ size_t ByteBuffer::getSerializedSize2_4_8Bytes(int64_t number) {
 }
 
 void ByteBuffer::putInt1_2_4Bytes(int32_t number) {
-    LOG_DEBUG2("putInt1_2_4Bytes(%i)", number);
     if (number < 0) {
         throw InputOutOfRangeException(vespalib::make_string(
                     "Cannot encode negative number."), VESPA_STRLOC);
@@ -607,7 +400,6 @@ void ByteBuffer::putInt1_2_4Bytes(int32_t number) {
 }
 
 void ByteBuffer::getInt1_2_4Bytes(int32_t & v) {
-    LOG_DEBUG2("getInt1_2_4Bytes(%i)", v);
     if (getRemaining() >= 1) {
         unsigned char flagByte = peekByte();
 
@@ -650,7 +442,6 @@ size_t ByteBuffer::getSerializedSize1_2_4Bytes(int32_t number) {
     }
 }
 void ByteBuffer::putInt1_4Bytes(int32_t number) {
-    LOG_DEBUG2("putInt1_4Bytes(%i)", number);
     if (number < 0) {
         throw InputOutOfRangeException(vespalib::make_string(
                     "Cannot encode negative number."), VESPA_STRLOC);
@@ -666,7 +457,6 @@ void ByteBuffer::putInt1_4Bytes(int32_t number) {
     }
 }
 void ByteBuffer::getInt1_4Bytes(int32_t & v) {
-    LOG_DEBUG2("getInt1_4Bytes(%i)", v);
     if (getRemaining() >= 1) {
         unsigned char flagByte = peekByte();
 
@@ -700,13 +490,11 @@ size_t ByteBuffer::getSerializedSize1_4Bytes(int32_t number) {
 }
 void ByteBuffer::getBytes(void *buffer, size_t count)
 {
-    LOG_DEBUG3("getBytes(%p, %" PRIu64 ")", buffer, count);
     const char *v = getBufferAtPos();
     incPos(count);
     memcpy(buffer, v, count);
 }
 void ByteBuffer::putBytes(const void *buf, size_t count) {
-    LOG_DEBUG3("putBytes(%p, %" PRIu64 ")", buf, count);
     if (__builtin_expect(getRemaining() < count, 0)) {
         throwOutOfBounds(getRemaining(), sizeof(count));
     } else {
@@ -721,8 +509,6 @@ std::string ByteBuffer::toString() {
 }
 
 void ByteBuffer::swap(ByteBuffer& other) {
-    LOG_DEBUG2("swap(%p)", &other);
-    std::swap(_bufHolder, other._bufHolder);
     std::swap(_buffer, other._buffer);
     std::swap(_len, other._len);
     std::swap(_pos, other._pos);
@@ -730,14 +516,8 @@ void ByteBuffer::swap(ByteBuffer& other) {
 }
 
 void ByteBuffer::cleanUp() {
-    LOG_DEBUG1("cleanUp()");
-    if (_bufHolder) {
-        _bufHolder->subRef();
-        _bufHolder = NULL;
-    } else {
-        Alloc().swap(_ownedBuffer);
-    }
-    _buffer = NULL;
+    Alloc().swap(_ownedBuffer);
+    _buffer = nullptr;
 }
 
 } // document
diff --git a/document/src/vespa/document/util/bytebuffer.h b/document/src/vespa/document/util/bytebuffer.h
index 6467e6d8bf0..a49bd55f8fe 100644
--- a/document/src/vespa/document/util/bytebuffer.h
+++ b/document/src/vespa/document/util/bytebuffer.h
@@ -15,7 +15,6 @@
 #pragma once
 
 #include <vespa/vespalib/util/alloc.h>
-#include <vespa/vespalib/util/referencecounter.h>
 
 namespace document {
 
@@ -31,6 +30,8 @@ public:
 
     ByteBuffer(const ByteBuffer &);
     ByteBuffer& operator=(const ByteBuffer &);
+    ByteBuffer(ByteBuffer &&) = default;
+    ByteBuffer& operator=(ByteBuffer &&) = default;
 
     ~ByteBuffer();
 
@@ -66,7 +67,7 @@ public:
     }
 
     /** Clear this buffer, and set free the underlying BufferHolder. */
-    void reset() { set(NULL, 0); }
+    void reset() { set(nullptr, 0); }
 
     /**
      * Creates a ByteBuffer object from another buffer. allocates
@@ -75,30 +76,17 @@ public:
      * @param buffer The buffer to copy.
      * @param len The length of the buffer.
      *
-     *  @return Returns a newly created bytebuffer object, or NULL
-     *  if buffer was NULL, or len was <=0.
+     *  @return Returns a newly created bytebuffer object, or nullptr
+     *  if buffer was nullptr, or len was <=0.
      */
     static ByteBuffer* copyBuffer(const char* buffer, size_t len);
 
-    std::unique_ptr<ByteBuffer> sliceCopy() const;
-
-    /**
-     * @throws BufferOutOfBoundsException If faulty range is given.
-     */
-    void sliceFrom(const ByteBuffer& buf, size_t from, size_t to);
-
     /** @return Returns the buffer pointed to by this object (at position 0) */
     char* getBuffer() const { return _buffer; }
 
     /** @return Returns the length of the buffer pointed to by this object. */
     size_t getLength() const { return _len; }
 
-    /**
-     * Adjust the length of the buffer. Only sane to shorten it, as you do not
-     * know what is ahead.
-     */
-    void setLength(size_t len) { _len = len; }
-
     /** @return Returns a pointer to the current position in the buffer. */
     char* getBufferAtPos() const { return _buffer + _pos; }
 
@@ -169,26 +157,19 @@ public:
         _limit=_len;
     }
 
-    void getNumericNetwork(uint8_t & v) { getNumeric(v); }
     void getNumeric(uint8_t & v);
-    void putNumericNetwork(uint8_t v) { putNumeric(v); }
     void putNumeric(uint8_t v);
     void getNumericNetwork(int16_t & v);
-    void getNumeric(int16_t & v);
     void putNumericNetwork(int16_t v);
-    void putNumeric(int16_t v);
     void getNumericNetwork(int32_t & v);
     void getNumeric(int32_t & v);
     void putNumericNetwork(int32_t v);
     void putNumeric(int32_t v);
-    void getNumericNetwork(float & v);
     void getNumeric(float & v);
-    void putNumericNetwork(float v);
-    void putNumeric(float v);
+
     void getNumericNetwork(int64_t & v);
     void getNumeric(int64_t& v);
     void putNumericNetwork(int64_t v);
-    void putNumeric(int64_t v);
     void getNumericNetwork(double & v);
     void getNumeric(double& v);
     void putNumericNetwork(double v);
@@ -197,21 +178,15 @@ public:
     void getByte(uint8_t & v)         { getNumeric(v); }
     void putByte(uint8_t v)           { putNumeric(v); }
     void getShortNetwork(int16_t & v) { getNumericNetwork(v); }
-    void getShort(int16_t & v)        { getNumeric(v); }
     void putShortNetwork(int16_t v)   { putNumericNetwork(v); }
-    void putShort(int16_t v)          { putNumeric(v); }
     void getIntNetwork(int32_t & v)   { getNumericNetwork(v); }
     void getInt(int32_t & v)          { getNumeric(v); }
     void putIntNetwork(int32_t v)     { putNumericNetwork(v); }
     void putInt(int32_t v)            { putNumeric(v); }
-    void getFloatNetwork(float & v)   { getNumericNetwork(v); }
     void getFloat(float & v)          { getNumeric(v); }
-    void putFloatNetwork(float v)     { putNumericNetwork(v); }
-    void putFloat(float v)            { putNumeric(v); }
     void getLongNetwork(int64_t & v)  { getNumericNetwork(v); }
     void getLong(int64_t& v)          { getNumeric(v); }
     void putLongNetwork(int64_t v)    { putNumericNetwork(v); }
-    void putLong(int64_t v)           { putNumeric(v); }
     void getDoubleNetwork(double & v) { getNumericNetwork(v); }
     void getDouble(double& v)         { getNumeric(v); }
     void putDoubleNetwork(double v)   { putNumericNetwork(v); }
@@ -343,7 +318,6 @@ public:
      *         reached
     */
     void getChar(char & val) { unsigned char t;getByte(t); val=t; }
-    void putChar(char val)   { putByte(static_cast<unsigned char>(val)); }
 
     /**
      *  Reads the given number of bytes into the given pointer, and updates the
@@ -365,39 +339,16 @@ public:
      */
     void putBytes(const void *buf, size_t count);
 
-    /** Debug */
-    void dump() const;
-
-    class BufferHolder : public vespalib::ReferenceCounter
-    {
-    private:
-        BufferHolder(const BufferHolder &);
-        BufferHolder& operator=(const BufferHolder &);
-
-    public:
-        BufferHolder(vespalib::alloc::Alloc buffer);
-        virtual ~BufferHolder();
-
-        vespalib::alloc::Alloc _buffer;
-    };
-
-    ByteBuffer(BufferHolder* buf, size_t pos, size_t len, size_t limit);
-
-    void set(BufferHolder* buf, size_t pos, size_t len, size_t limit);
-
 private:
     char * _buffer;
     size_t _len;
     size_t _pos;
     size_t _limit;
-    mutable BufferHolder   * _bufHolder;
     vespalib::alloc::Alloc _ownedBuffer;
 public:
 
     std::string toString();
-
     void swap(ByteBuffer& other);
-
     void cleanUp();
 };
 
diff --git a/storage/src/vespa/storage/common/storagelink.cpp b/storage/src/vespa/storage/common/storagelink.cpp
index f73eb3ea36d..065f0b0b750 100644
--- a/storage/src/vespa/storage/common/storagelink.cpp
+++ b/storage/src/vespa/storage/common/storagelink.cpp
@@ -4,6 +4,7 @@
 #include "bucketmessages.h"
 #include <vespa/vespalib/util/backtrace.h>
 #include <sstream>
+#include <cassert>
 
 #include <vespa/log/bufferedlogger.h>
 LOG_SETUP(".application.link");
diff --git a/storage/src/vespa/storage/distributor/maintenance/simplemaintenancescanner.cpp b/storage/src/vespa/storage/distributor/maintenance/simplemaintenancescanner.cpp
index e143f4d8570..15a57c1e7ee 100644
--- a/storage/src/vespa/storage/distributor/maintenance/simplemaintenancescanner.cpp
+++ b/storage/src/vespa/storage/distributor/maintenance/simplemaintenancescanner.cpp
@@ -2,6 +2,7 @@
 #include "simplemaintenancescanner.h"
 #include <vespa/storage/distributor/distributor_bucket_space.h>
 #include <ostream>
+#include <cassert>
 
 namespace storage::distributor {
 
@@ -16,10 +17,10 @@ SimpleMaintenanceScanner::SimpleMaintenanceScanner(BucketPriorityDatabase& bucke
 {
 }
 
-SimpleMaintenanceScanner::~SimpleMaintenanceScanner() {}
+SimpleMaintenanceScanner::~SimpleMaintenanceScanner() = default;
 
-SimpleMaintenanceScanner::PendingMaintenanceStats::PendingMaintenanceStats() {}
-SimpleMaintenanceScanner::PendingMaintenanceStats::~PendingMaintenanceStats() {}
+SimpleMaintenanceScanner::PendingMaintenanceStats::PendingMaintenanceStats() = default;
+SimpleMaintenanceScanner::PendingMaintenanceStats::~PendingMaintenanceStats() = default;
 SimpleMaintenanceScanner::PendingMaintenanceStats::PendingMaintenanceStats(const PendingMaintenanceStats &) = default;
 SimpleMaintenanceScanner::PendingMaintenanceStats &
 SimpleMaintenanceScanner::PendingMaintenanceStats::operator = (const PendingMaintenanceStats &) = default;
diff --git a/storage/src/vespa/storage/distributor/throttlingoperationstarter.cpp b/storage/src/vespa/storage/distributor/throttlingoperationstarter.cpp
index abd9778d72c..9e3230a0f34 100644
--- a/storage/src/vespa/storage/distributor/throttlingoperationstarter.cpp
+++ b/storage/src/vespa/storage/distributor/throttlingoperationstarter.cpp
@@ -1,6 +1,7 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "throttlingoperationstarter.h"
+#include <cassert>
 
 namespace storage::distributor {
 
@@ -10,8 +11,7 @@ ThrottlingOperationStarter::ThrottlingOperation::~ThrottlingOperation()
 }
 
 bool
-ThrottlingOperationStarter::canStart(uint32_t currentOperationCount,
-                                    Priority priority) const
+ThrottlingOperationStarter::canStart(uint32_t currentOperationCount, Priority priority) const
 {
     uint32_t variablePending(_maxPending - _minPending);
     uint32_t maxPendingForPri(_minPending + variablePending*((255.0 - priority) / 255.0));
diff --git a/vespalib/src/vespa/vespalib/util/alloc.h b/vespalib/src/vespa/vespalib/util/alloc.h
index b52cace45a5..03ebc2807f9 100644
--- a/vespalib/src/vespa/vespalib/util/alloc.h
+++ b/vespalib/src/vespa/vespalib/util/alloc.h
@@ -59,13 +59,13 @@ public:
     bool resize_inplace(size_t newSize);
     Alloc(const Alloc &) = delete;
     Alloc & operator = (const Alloc &) = delete;
-    Alloc(Alloc && rhs) :
+    Alloc(Alloc && rhs) noexcept :
         _alloc(rhs._alloc),
         _allocator(rhs._allocator)
     {
         rhs.clear();
     }
-    Alloc & operator=(Alloc && rhs) {
+    Alloc & operator=(Alloc && rhs) noexcept {
         if (this != & rhs) {
             if (_alloc.first != nullptr) {
                 _allocator->free(_alloc);