Merge pull request #13202 from vespa-engine/balder/cleanup-buffer-handling

Try to hide implementation.

23 files changed, 284 insertions, 685 deletions

diff --git a/searchlib/src/tests/bitcompression/expgolomb/expgolomb_test.cpp b/searchlib/src/tests/bitcompression/expgolomb/expgolomb_test.cpp
index c678d88427f..ce36bc3503a 100644
--- a/searchlib/src/tests/bitcompression/expgolomb/expgolomb_test.cpp
+++ b/searchlib/src/tests/bitcompression/expgolomb/expgolomb_test.cpp
@@ -38,7 +38,7 @@ public:
     virtual uint64_t decodeSmallApply() = 0;
     virtual void skipSmall() = 0;
 
-    virtual ~IDecodeFunc() { }
+    virtual ~IDecodeFunc() = default;
 
 };
 
@@ -66,7 +66,7 @@ public:
     {
     }
 
-    virtual uint64_t decode() override
+    uint64_t decode() override
     {
         unsigned int length;
         uint64_t val64;
@@ -75,14 +75,14 @@ public:
         return val64;
     }
 
-    virtual void skip() override
+    void skip() override
     {
         unsigned int length;
         UC64_SKIPEXPGOLOMB(_dc._val, _dc._valI, _dc._preRead, 
                              _dc._cacheInt, _kValue, EC);
     }
 
-    virtual uint64_t decodeSmall() override
+    uint64_t decodeSmall() override
     {
         unsigned int length;
         uint64_t val64;
@@ -91,7 +91,7 @@ public:
         return val64;
     }
 
-    virtual uint64_t decodeSmallApply() override
+    uint64_t decodeSmallApply() override
     {
         unsigned int length;
         uint64_t val64;
@@ -100,7 +100,7 @@ public:
         return val64;
     }
 
-    virtual void skipSmall() override
+    void skipSmall() override
     {
         unsigned int length;
         UC64_SKIPEXPGOLOMB_SMALL(_dc._val, _dc._valI, _dc._preRead, 
@@ -201,27 +201,19 @@ public:
 public:
     DecodeFuncFactories();
 
-    void
-    addConstKFactory(int kValue, IDecodeFuncFactory factory)
-    {
+    void addConstKFactory(int kValue, IDecodeFuncFactory factory) {
         (void) kValue;
         assert(static_cast<unsigned int>(kValue) == _constK.size());
         _constK.push_back(factory);
     }
 
-    IDecodeFuncFactory
-    getConstKFactory(int kValue) const
-    {
+    IDecodeFuncFactory getConstKFactory(int kValue) const {
         assert(kValue >= 0 &&
                static_cast<unsigned int>(kValue) < _constK.size());
         return _constK[kValue];
     }
 
-    IDecodeFuncFactory
-    getVarKFactory() const
-    {
-        return _varK;
-    }
+    IDecodeFuncFactory getVarKFactory() const { return _varK; }
 };
 
 
@@ -294,9 +286,7 @@ public:
     using EC = EncodeContext64Base;
 
     void fillRandNums();
-
-    void
-    calcBoundaries(int kValue, bool small, std::vector<uint64_t> &v);
+    void calcBoundaries(int kValue, bool small, std::vector<uint64_t> &v);
 
     void
     testBoundaries(int kValue, bool small,
@@ -336,8 +326,7 @@ TestFixtureBase::fillRandNums()
 }
 
 
-namespace
-{
+namespace {
 
 /*
  * Add values around a calculated boundary, to catch off by one errors.
@@ -361,8 +350,7 @@ addBoundary(uint64_t boundary, uint64_t maxVal, std::vector<uint64_t> &v)
 }
 
 void
-TestFixtureBase::calcBoundaries(int kValue, bool small,
-                                std::vector<uint64_t> &v)
+TestFixtureBase::calcBoundaries(int kValue, bool small, std::vector<uint64_t> &v)
 {
     const char *smallStr = small ? "small" : "not small";
     v.push_back(0);
@@ -478,22 +466,11 @@ public:
                    std::vector<uint64_t> &v,
                    IDecodeFuncFactory f,
                    search::ComprFileWriteContext &wc);
-    void
-    testBoundaries(int kValue, bool small, std::vector<uint64_t> &v);
-
-    void
-    testBoundaries();
-
-    void
-    testRandNums(int kValue,
-                 IDecodeFuncFactory f,
-                 search::ComprFileWriteContext &wc);
-
-    void
-    testRandNums(int kValue);
-
-    void
-    testRandNums();
+    void testBoundaries(int kValue, bool small, std::vector<uint64_t> &v);
+    void testBoundaries();
+    void testRandNums(int kValue, IDecodeFuncFactory f, search::ComprFileWriteContext &wc);
+    void testRandNums(int kValue);
+    void testRandNums();
 };
 
 
@@ -504,9 +481,9 @@ TestFixture<bigEndian>::testBoundaries(int kValue, bool small,
                                        IDecodeFuncFactory f,
                                        search::ComprFileWriteContext &wc)
 {
-    DC dc(static_cast<const uint64_t *>(wc._comprBuf), 0);
-    DC dcSkip(static_cast<const uint64_t *>(wc._comprBuf), 0);
-    DC dcApply(static_cast<const uint64_t *>(wc._comprBuf), 0);
+    DC dc(wc.getComprBuf(), 0);
+    DC dcSkip(wc.getComprBuf(), 0);
+    DC dcApply(wc.getComprBuf(), 0);
     std::unique_ptr<IDecodeFunc> df((*f)(dc, kValue));
     std::unique_ptr<IDecodeFunc> dfSkip((*f)(dcSkip, kValue));
     std::unique_ptr<IDecodeFunc> dfApply((*f)(dcApply, kValue));
@@ -517,8 +494,7 @@ TestFixture<bigEndian>::testBoundaries(int kValue, bool small,
 
 template <bool bigEndian>
 void
-TestFixture<bigEndian>::testBoundaries(int kValue, bool small,
-                                       std::vector<uint64_t> &v)
+TestFixture<bigEndian>::testBoundaries(int kValue, bool small, std::vector<uint64_t> &v)
 {
     EC e;
     search::ComprFileWriteContext wc(e);
@@ -562,12 +538,10 @@ TestFixture<bigEndian>::testBoundaries()
 
 template <bool bigEndian>
 void
-TestFixture<bigEndian>::testRandNums(int kValue,
-                                     IDecodeFuncFactory f,
-                                     search::ComprFileWriteContext &wc)
+TestFixture<bigEndian>::testRandNums(int kValue, IDecodeFuncFactory f, search::ComprFileWriteContext &wc)
 {
-    DC dc(static_cast<const uint64_t *>(wc._comprBuf), 0);
-    DC dcSkip(static_cast<const uint64_t *>(wc._comprBuf), 0);
+    DC dc(wc.getComprBuf(), 0);
+    DC dcSkip(wc.getComprBuf(), 0);
     std::unique_ptr<IDecodeFunc> df((*f)(dc, kValue));
     std::unique_ptr<IDecodeFunc> dfSkip((*f)(dcSkip, kValue));
     testRandNums(dc, dcSkip, *df, *dfSkip);
diff --git a/searchlib/src/vespa/searchlib/bitcompression/compression.h b/searchlib/src/vespa/searchlib/bitcompression/compression.h
index 56dcee2751f..e6b171ec871 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/compression.h
+++ b/searchlib/src/vespa/searchlib/bitcompression/compression.h
@@ -750,7 +750,7 @@ public:
           _fileWriteBias(other._fileWriteBias)
     { }
 
-    ~EncodeContext64Base() { }
+    ~EncodeContext64Base() = default;
 
     EncodeContext64Base &
     operator=(const EncodeContext64Base &rhs)
@@ -767,8 +767,8 @@ public:
     /**
      * Get number of used units (e.g. _valI - start)
      */
-    int getUsedUnits(void *start) override {
-        return _valI - static_cast<uint64_t *>(start);
+    int getUsedUnits(const uint64_t * start) override {
+        return _valI - start;
     }
 
     /**
@@ -783,9 +783,9 @@ public:
      */
     void
     afterWrite(search::ComprBuffer &cbuf, uint32_t remainingUnits, uint64_t bufferStartFilePos) override {
-        _valI = static_cast<uint64_t *>(cbuf._comprBuf) + remainingUnits;
+        _valI = cbuf.getComprBuf() + remainingUnits;
         _fileWriteBias = (bufferStartFilePos -
-                          reinterpret_cast<unsigned long>(cbuf._comprBuf) +
+                          reinterpret_cast<unsigned long>(cbuf.getComprBuf()) +
                           sizeof(uint64_t)) << 3;
         adjustBufSize(cbuf);
     }
@@ -796,12 +796,9 @@ public:
     void adjustBufSize(search::ComprBuffer &cbuf) override {
         uint64_t fileWriteOffset =
             (_fileWriteBias +
-             ((reinterpret_cast<unsigned long>(cbuf._comprBuf) -
+             ((reinterpret_cast<unsigned long>(cbuf.getComprBuf()) -
                sizeof(uint64_t)) << 3)) >> 3;
-        _valE = static_cast<uint64_t *>(cbuf._comprBuf) +
-                cbuf._aligner.adjustElements(
-                        fileWriteOffset / sizeof(uint64_t),
-                        cbuf._comprBufSize);
+        _valE = cbuf.getAdjustedBuf(fileWriteOffset);
     }
 
     uint32_t getUnitByteSize() const override {
@@ -809,11 +806,9 @@ public:
     }
 
     void setupWrite(search::ComprBuffer &cbuf) {
-        _valI = static_cast<uint64_t *>(cbuf._comprBuf);
+        _valI = cbuf.getComprBuf();
 
-        _fileWriteBias =
-            (sizeof(uint64_t) -
-             reinterpret_cast<unsigned long>(cbuf._comprBuf)) << 3;
+        _fileWriteBias = (sizeof(uint64_t) - reinterpret_cast<unsigned long>(cbuf.getComprBuf())) << 3;
         // Buffer for compressed data now has padding after it
         adjustBufSize(cbuf);
         _cacheInt = 0;
@@ -844,10 +839,6 @@ public:
                          _cacheFree;
     }
 
-    uint64_t getBitPosV() const override {
-        return getWriteOffset();
-    }
-
     /*
      * Return max value that can be exp golomb encoded with our implementation
      * ot the encoding method. Handling of larger numbers would require changes
@@ -1177,10 +1168,7 @@ public:
     {
     }
 
-    virtual
-    ~DecodeContext64Base()
-    {
-    }
+    virtual ~DecodeContext64Base() = default;
 
     DecodeContext64Base &
     operator=(const DecodeContext64Base &rhs)
@@ -1321,14 +1309,10 @@ private:
 public:
     typedef EncodeContext64<bigEndian> EC;
 
-    DecodeContext64()
-        : DecodeContext64Base()
-    {
-    }
+    DecodeContext64() = default;
 
 
-    DecodeContext64(const uint64_t *compr,
-                    int bitOffset)
+    DecodeContext64(const uint64_t *compr, int bitOffset)
         : DecodeContext64Base(compr + 1,
                               reinterpret_cast<const uint64_t *>(PTRDIFF_MAX),
                               nullptr,
@@ -1346,9 +1330,7 @@ public:
      * data beyond is available, to avoid issues when prefetching bits
      * into two registers (_val and _cacheInt).
      */
-    DecodeContext64(const uint64_t *compr,
-                    int bitOffset,
-                    uint64_t bitLength)
+    DecodeContext64(const uint64_t *compr, int bitOffset, uint64_t bitLength)
         : DecodeContext64Base(compr + 1,
                               nullptr,
                               nullptr,
@@ -1554,52 +1536,26 @@ public:
     using ParentClass::readHeader;
     using ParentClass::readBytes;
 
-    FeatureDecodeContext()
-        : ParentClass()
-    {
-    }
+    FeatureDecodeContext() = default;
 
-    FeatureDecodeContext(const uint64_t *compr,
-                         int bitOffset)
+    FeatureDecodeContext(const uint64_t *compr, int bitOffset)
         : ParentClass(compr, bitOffset)
     {
     }
 
-    FeatureDecodeContext(const uint64_t *compr,
-                         int bitOffset,
-                         uint64_t bitLength)
+    FeatureDecodeContext(const uint64_t *compr, int bitOffset, uint64_t bitLength)
         : ParentClass(compr, bitOffset, bitLength)
     {
     }
 
-    virtual void
-    readHeader(const vespalib::GenericHeader &header,
-               const vespalib::string &prefix);
-
-    virtual const vespalib::string &
-    getIdentifier() const;
-
-    virtual void
-    readFeatures(DocIdAndFeatures &features);
+    virtual void readHeader(const vespalib::GenericHeader &header, const vespalib::string &prefix);
 
-    virtual void
-    skipFeatures(unsigned int count);
-
-    virtual void
-    unpackFeatures(const search::fef::TermFieldMatchDataArray &matchData,
-                   uint32_t docId);
-
-    /*
-     * Set parameters.
-     */
-    virtual void
-    setParams(const PostingListParams &params);
-
-    /*
-     * Get current parameters.
-     */
-    virtual void
-    getParams(PostingListParams &params) const;
+    virtual const vespalib::string & getIdentifier() const;
+    virtual void readFeatures(DocIdAndFeatures &features);
+    virtual void skipFeatures(unsigned int count);
+    virtual void unpackFeatures(const search::fef::TermFieldMatchDataArray &matchData, uint32_t docId);
+    virtual void setParams(const PostingListParams &params);
+    virtual void getParams(PostingListParams &params) const;
 };
 
 typedef FeatureDecodeContext<true> FeatureDecodeContextBE;
@@ -1633,9 +1589,7 @@ public:
         return *this;
     }
 
-    void
-    setWriteContext(search::ComprFileWriteContext *writeContext)
-    {
+    void setWriteContext(search::ComprFileWriteContext *writeContext) {
         _writeContext = writeContext;
     }
 
@@ -1653,29 +1607,18 @@ public:
 
     using ParentClass::writeBits;
 
-    void
-    writeBits(const uint64_t *bits, uint32_t bitOffset, uint32_t bitLength);
-
-    void
-    writeBytes(vespalib::ConstArrayRef<char> buf);
-
-    void
-    writeString(vespalib::stringref buf);
-
-    virtual void
-    writeHeader(const vespalib::GenericHeader &header);
+    void writeBits(const uint64_t *bits, uint32_t bitOffset, uint32_t bitLength);
+    void writeBytes(vespalib::ConstArrayRef<char> buf);
+    void writeString(vespalib::stringref buf);
+    virtual void writeHeader(const vespalib::GenericHeader &header);
 
-    void
-    writeComprBufferIfNeeded()
-    {
+    void writeComprBufferIfNeeded() {
         if (_valI >= _valE) {
             _writeContext->writeComprBuffer(false);
         }
     }
 
-    void
-    writeComprBuffer()
-    {
+    void writeComprBuffer() {
         _writeContext->writeComprBuffer(true);
     }
 
@@ -1689,26 +1632,11 @@ public:
         writeComprBufferIfNeeded();
     }
 
-    virtual void
-    readHeader(const vespalib::GenericHeader &header,
-               const vespalib::string &prefix);
-
-    virtual void
-    writeHeader(vespalib::GenericHeader &header,
-                const vespalib::string &prefix) const;
-
+    virtual void readHeader(const vespalib::GenericHeader &header, const vespalib::string &prefix);
+    virtual void writeHeader(vespalib::GenericHeader &header, const vespalib::string &prefix) const;
     virtual const vespalib::string &getIdentifier() const;
-
     virtual void writeFeatures(const DocIdAndFeatures &features);
-
-    /*
-     * Set parameters.
-     */
     virtual void setParams(const PostingListParams &params);
-
-    /*
-     * Get current parameters.
-     */
     virtual void getParams(PostingListParams &params) const;
 };
 
diff --git a/searchlib/src/vespa/searchlib/bitcompression/countcompression.cpp b/searchlib/src/vespa/searchlib/bitcompression/countcompression.cpp
index e0be7e9b890..e056ce3169f 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/countcompression.cpp
+++ b/searchlib/src/vespa/searchlib/bitcompression/countcompression.cpp
@@ -1,6 +1,5 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include "compression.h"
 #include "countcompression.h"
 #include <vespa/searchlib/index/postinglistcounts.h>
 
diff --git a/searchlib/src/vespa/searchlib/bitcompression/pagedict4.cpp b/searchlib/src/vespa/searchlib/bitcompression/pagedict4.cpp
index 4f947c6c55d..cf8f4173f5b 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/pagedict4.cpp
+++ b/searchlib/src/vespa/searchlib/bitcompression/pagedict4.cpp
@@ -1,12 +1,9 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "pagedict4.h"
-#include "compression.h"
-#include "countcompression.h"
 #include <vespa/searchlib/index/postinglistcounts.h>
 #include <vespa/searchlib/index/dictionaryfile.h>
 #include <vespa/vespalib/util/arrayref.h>
-#include <sstream>
 
 #include <vespa/log/log.h>
 LOG_SETUP(".pagedict4");
@@ -43,17 +40,15 @@ setDecoderPosition(PostingListCountFileDecodeContext &ctx,
                    const ComprBuffer &cb,
                    uint64_t offset)
 {
-    ctx.afterRead(cb._comprBuf,
-                  cb._comprBufSize,
-                  cb._comprBufSize * sizeof(uint64_t),
+    ctx.afterRead(cb.getComprBuf(),
+                  cb.getComprBufSize(),
+                  cb.getComprBufSize() * sizeof(uint64_t),
                   false);
-    setDecoderPositionHelper(ctx, cb._comprBuf, offset);
+    setDecoderPositionHelper(ctx, cb.getComprBuf(), offset);
 }
 
-
 }
 
-
 uint32_t
 PageDict4PageParams::getFileHeaderPad(uint32_t offset)
 {
@@ -62,7 +57,6 @@ PageDict4PageParams::getFileHeaderPad(uint32_t offset)
 }
 
 
-typedef index::PostingListCounts Counts;
 typedef PageDict4StartOffset StartOffset;
 
 #define K_VALUE_COUNTFILE_L1_FILEOFFSET 7
@@ -158,13 +152,9 @@ readStartOffset(PostingListCountFileDecodeContext &d,
     uint64_t val64;
     const bool bigEndian = true;
     UC64_DECODECONTEXT_LOAD(o, d._);
-    UC64_DECODEEXPGOLOMB_NS(o,
-                            fileOffsetK,
-                            EC);
+    UC64_DECODEEXPGOLOMB_NS(o, fileOffsetK, EC);
     startOffset._fileOffset += val64;
-    UC64_DECODEEXPGOLOMB_NS(o,
-                            accNumDocsK,
-                            EC);
+    UC64_DECODEEXPGOLOMB_NS(o, accNumDocsK, EC);
     startOffset._accNumDocs += val64;
     UC64_DECODECONTEXT_STORE(o, d._);
     d.readComprBufferIfNeeded();
@@ -181,9 +171,7 @@ PageDict4SSWriter::PageDict4SSWriter(SSEC &sse)
 {
 }
 
-PageDict4SSWriter::~PageDict4SSWriter()
-{
-}
+PageDict4SSWriter::~PageDict4SSWriter() = default;
 
 void
 PageDict4SSWriter::addL6Skip(vespalib::stringref word,
@@ -257,8 +245,7 @@ PageDict4SSWriter::flush()
 }
 
 
-PageDict4SPWriter::PageDict4SPWriter(SSWriter &ssWriter,
-                                     EC &spe)
+PageDict4SPWriter::PageDict4SPWriter(SSWriter &ssWriter, EC &spe)
     : _eL3(),
       _wcL3(_eL3),
       _eL4(),
@@ -329,9 +316,7 @@ PageDict4SPWriter::setup()
 }
 
 
-PageDict4SPWriter::~PageDict4SPWriter()
-{
-}
+PageDict4SPWriter::~PageDict4SPWriter() = default;
 
 
 void
@@ -365,16 +350,16 @@ PageDict4SPWriter::flushPage()
     e.writeComprBufferIfNeeded();
     if (_prevL5Size > 0) {
         _eL5.flush();
-        const uint64_t *l5Buf = static_cast<const uint64_t *>(_wcL5._comprBuf);
+        const uint64_t *l5Buf = _wcL5.getComprBuf();
         e.writeBits(l5Buf, 0, _prevL5Size);
     }
     if (_prevL4Size > 0) {
         _eL4.flush();
-        const uint64_t *l4Buf = static_cast<const uint64_t *>(_wcL4._comprBuf);
+        const uint64_t *l4Buf = _wcL4.getComprBuf();
         e.writeBits(l4Buf, 0, _prevL4Size);
     }
     _eL3.flush();
-    const uint64_t *l3Buf = static_cast<const uint64_t *>(_wcL3._comprBuf);
+    const uint64_t *l3Buf = _wcL3.getComprBuf();
     e.writeBits(l3Buf, 0, _prevL3Size);
     uint32_t padding = getPageBitSize() - _headerSize - _prevL5Size - _prevL4Size -
                        _prevL3Size - wordsSize * 8;
@@ -576,8 +561,7 @@ PageDict4SPWriter::addL5Skip(size_t &lcp)
 }
 
 
-PageDict4PWriter::PageDict4PWriter(SPWriter &spWriter,
-                                   EC &pe)
+PageDict4PWriter::PageDict4PWriter(SPWriter &spWriter, EC &pe)
     : _eCounts(),
       _wcCounts(_eCounts),
       _eL1(),
@@ -646,9 +630,7 @@ PageDict4PWriter::setup()
 }
 
 
-PageDict4PWriter::~PageDict4PWriter()
-{
-}
+PageDict4PWriter::~PageDict4PWriter() = default;
 
 
 void
@@ -679,17 +661,16 @@ PageDict4PWriter::flushPage()
     e.writeComprBufferIfNeeded();
     if (_l2Size > 0) {
         _eL2.flush();
-        const uint64_t *l2Buf = static_cast<const uint64_t *>(_wcL2._comprBuf);
+        const uint64_t *l2Buf = _wcL2.getComprBuf();
         e.writeBits(l2Buf, 0, _l2Size);
     }
     if (_l1Size > 0) {
         _eL1.flush();
-        const uint64_t *l1Buf = static_cast<const uint64_t *>(_wcL1._comprBuf);
+        const uint64_t *l1Buf = _wcL1.getComprBuf();
         e.writeBits(l1Buf, 0, _l1Size);
     }
     _eCounts.flush();
-    const uint64_t *countsBuf = static_cast<const uint64_t *>
-                                (_wcCounts._comprBuf);
+    const uint64_t *countsBuf = _wcCounts.getComprBuf();
     e.writeBits(countsBuf, 0, _countsSize);
     uint32_t padding = getPageBitSize() - _headerSize - _l2Size - _l1Size -
                        _countsSize - _countsWordOffset * 8;
@@ -755,9 +736,7 @@ PageDict4PWriter::resetPage()
 
 
 void
-PageDict4PWriter::
-addCounts(vespalib::stringref word,
-          const Counts &counts)
+PageDict4PWriter::addCounts(vespalib::stringref word, const Counts &counts)
 {
     assert(_countsWordOffset == _words.size());
     size_t lcp = getLCP(_pendingCountsWord, _countsWord);
@@ -812,8 +791,7 @@ addCounts(vespalib::stringref word,
 
 /* Private use */
 void
-PageDict4PWriter::addOverflowCounts(vespalib::stringref word,
-                                    const Counts &counts)
+PageDict4PWriter::addOverflowCounts(vespalib::stringref word, const Counts &counts)
 {
     assert(_countsEntries == 0);
     assert(_countsSize == 0);
@@ -924,10 +902,7 @@ PageDict4SSLookupRes()
 }
 
 
-PageDict4SSLookupRes::
-~PageDict4SSLookupRes()
-{
-}
+PageDict4SSLookupRes::~PageDict4SSLookupRes() = default;
 
 
 PageDict4SSReader::
@@ -954,15 +929,11 @@ PageDict4SSReader(ComprBuffer &cb,
       _overflows()
 {
     // Reference existing compressed buffer
-    _cb._comprBuf = cb._comprBuf;
-    _cb._comprBufSize = cb._comprBufSize;
+    _cb.referenceComprBuf(cb);
 }
 
 
-PageDict4SSReader::
-~PageDict4SSReader()
-{
-}
+PageDict4SSReader::~PageDict4SSReader() = default;
 
 
 void
@@ -1031,9 +1002,7 @@ PageDict4SSReader::setup(DC &ssd)
                         K_VALUE_COUNTFILE_L6_FILEOFFSET,
                         K_VALUE_COUNTFILE_L6_ACCNUMDOCS);
         UC64_DECODECONTEXT_LOAD(o, dL6._);
-        UC64_DECODEEXPGOLOMB_NS(o,
-                                K_VALUE_COUNTFILE_L6_WORDNUM,
-                                EC);
+        UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_WORDNUM, EC);
         l6WordNum += val64;
         UC64_DECODECONTEXT_STORE(o, dL6._);
         dL6.smallAlign(8);
@@ -1051,9 +1020,7 @@ PageDict4SSReader::setup(DC &ssd)
             forceL7Entry = true; // Add new L7 entry as soon as possible
         } else {
             UC64_DECODECONTEXT_LOAD(o, dL6._);
-            UC64_DECODEEXPGOLOMB_NS(o,
-                                    K_VALUE_COUNTFILE_L6_PAGENUM,
-                                    EC);
+            UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_PAGENUM, EC);
             pageNum += val64;
             ++sparsePageNum;
             UC64_DECODECONTEXT_STORE(o, dL6._);
@@ -1151,9 +1118,7 @@ lookup(vespalib::stringref key)
                         K_VALUE_COUNTFILE_L6_FILEOFFSET,
                         K_VALUE_COUNTFILE_L6_ACCNUMDOCS);
         UC64_DECODECONTEXT_LOAD(o, dL6._);
-        UC64_DECODEEXPGOLOMB_NS(o,
-                                K_VALUE_COUNTFILE_L6_WORDNUM,
-                                EC);
+        UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_WORDNUM, EC);
         wordNum += val64;
         UC64_DECODECONTEXT_STORE(o, dL6._);
         dL6.smallAlign(8);
@@ -1183,9 +1148,7 @@ lookup(vespalib::stringref key)
                 break;  // key <= counts
             }
             UC64_DECODECONTEXT_LOAD(o, dL6._);
-            UC64_DECODEEXPGOLOMB_NS(o,
-                                    K_VALUE_COUNTFILE_L6_PAGENUM,
-                                    EC);
+            UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_PAGENUM, EC);
             pageNum += val64;
             ++sparsePageNum;
             UC64_DECODECONTEXT_STORE(o, dL6._);
@@ -1222,9 +1185,7 @@ lookupOverflow(uint64_t wordNum) const
     assert(!_overflows.empty());
 
     OverflowVector::const_iterator lb =
-        std::lower_bound(_overflows.begin(),
-                         _overflows.end(),
-                         wordNum);
+        std::lower_bound(_overflows.begin(), _overflows.end(), wordNum);
 
     assert(lb != _overflows.end());
     assert(lb->_wordNum == wordNum);
@@ -1272,9 +1233,7 @@ lookupOverflow(uint64_t wordNum) const
                     K_VALUE_COUNTFILE_L6_FILEOFFSET,
                     K_VALUE_COUNTFILE_L6_ACCNUMDOCS);
     UC64_DECODECONTEXT_LOAD(o, dL6._);
-    UC64_SKIPEXPGOLOMB_NS(o,
-                          K_VALUE_COUNTFILE_L6_WORDNUM,
-                          EC);
+    UC64_SKIPEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_WORDNUM, EC);
     UC64_DECODECONTEXT_STORE(o, dL6._);
 
     dL6.smallAlign(8);
@@ -1311,10 +1270,7 @@ PageDict4SPLookupRes()
 }
 
 
-PageDict4SPLookupRes::
-~PageDict4SPLookupRes()
-{
-}
+PageDict4SPLookupRes::~PageDict4SPLookupRes() = default;
 
 
 void
@@ -1398,9 +1354,7 @@ lookup(const SSReader &ssReader,
                         K_VALUE_COUNTFILE_L5_FILEOFFSET,
                         K_VALUE_COUNTFILE_L5_ACCNUMDOCS);
         UC64_DECODECONTEXT_LOAD(o, dL5._);
-        UC64_DECODEEXPGOLOMB_NS(o,
-                                K_VALUE_COUNTFILE_L5_WORDNUM,
-                                EC);
+        UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L5_WORDNUM, EC);
         l3WordNum += val64;
         UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L5_L3OFFSET, EC);
         l3Offset += val64;
@@ -1441,9 +1395,7 @@ lookup(const SSReader &ssReader,
                         K_VALUE_COUNTFILE_L4_FILEOFFSET,
                         K_VALUE_COUNTFILE_L4_ACCNUMDOCS);
         UC64_DECODECONTEXT_LOAD(o, dL4._);
-        UC64_DECODEEXPGOLOMB_NS(o,
-                                K_VALUE_COUNTFILE_L4_WORDNUM,
-                                EC);
+        UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L4_WORDNUM, EC);
         l3WordNum += val64;
         UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L4_L3OFFSET, EC);
         l3Offset += val64;
@@ -1487,9 +1439,7 @@ lookup(const SSReader &ssReader,
         uint64_t val64;
         const bool bigEndian = true;
         UC64_DECODECONTEXT_LOAD(o, dL3._);
-        UC64_DECODEEXPGOLOMB_NS(o,
-                                K_VALUE_COUNTFILE_L3_WORDNUM,
-                                EC);
+        UC64_DECODEEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L3_WORDNUM, EC);
         UC64_DECODECONTEXT_STORE(o, dL3._);
         l3WordNum += val64;
         --l3Residue;
@@ -1515,10 +1465,7 @@ PageDict4PLookupRes()
 }
 
 
-PageDict4PLookupRes::
-~PageDict4PLookupRes()
-{
-}
+PageDict4PLookupRes::~PageDict4PLookupRes() = default;
 
 bool
 PageDict4PLookupRes::
@@ -1703,9 +1650,7 @@ lookup(const SSReader &ssReader,
    return _res;
 }
 
-PageDict4Reader::PageDict4Reader(const SSReader &ssReader,
-                                 DC &spd,
-                                 DC &pd)
+PageDict4Reader::PageDict4Reader(const SSReader &ssReader, DC &spd, DC &pd)
     : _pd(pd),
       _countsResidue(0),
       _ssReader(ssReader),
@@ -1759,9 +1704,7 @@ PageDict4Reader::setup()
 }
 
 
-PageDict4Reader::~PageDict4Reader()
-{
-}
+PageDict4Reader::~PageDict4Reader() = default;
 
 namespace {
 
@@ -2126,9 +2069,7 @@ PageDict4Reader::decodeSSWord(vespalib::string &word)
             _ssd.readCounts(counts);
         } else {
             UC64_DECODECONTEXT_LOAD(o, _ssd._);
-            UC64_SKIPEXPGOLOMB_NS(o,
-                                  K_VALUE_COUNTFILE_L6_PAGENUM,
-                                  EC);
+            UC64_SKIPEXPGOLOMB_NS(o, K_VALUE_COUNTFILE_L6_PAGENUM, EC);
             UC64_DECODECONTEXT_STORE(o, _ssd._);
             break;
         }
@@ -2137,9 +2078,7 @@ PageDict4Reader::decodeSSWord(vespalib::string &word)
 }
 
 void
-PageDict4Reader::readCounts(vespalib::string &word,
-                            uint64_t &wordNum,
-                            Counts &counts)
+PageDict4Reader::readCounts(vespalib::string &word, uint64_t &wordNum, Counts &counts)
 {
     if (_countsResidue > 0) {
         assert(_cc != _ce);
@@ -2213,10 +2152,8 @@ PageDict4Reader::readCounts(vespalib::string &word,
     }
 }
 
-
 void
-PageDict4Reader::readOverflowCounts(vespalib::string &word,
-                                    Counts &counts)
+PageDict4Reader::readOverflowCounts(vespalib::string &word, Counts &counts)
 {
     uint64_t wordNum = _pd.readBits(64);
 
diff --git a/searchlib/src/vespa/searchlib/bitcompression/pagedict4.h b/searchlib/src/vespa/searchlib/bitcompression/pagedict4.h
index af05a71e518..cfd9277b184 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/pagedict4.h
+++ b/searchlib/src/vespa/searchlib/bitcompression/pagedict4.h
@@ -2,9 +2,9 @@
 
 #pragma once
 
+#include "countcompression.h"
 #include <limits>
 #include <vespa/vespalib/stllike/string.h>
-#include "countcompression.h"
 
 namespace search::bitcompression {
 
@@ -153,8 +153,7 @@ public:
                       const StartOffset &startOffset,
                       uint64_t wordNum);
 
-    void
-    flush();
+    void flush();
 };
 
 
@@ -240,58 +239,26 @@ private:
     EC &_spe;
 
 public:
-    PageDict4SPWriter(SSWriter &sparseSparsewriter,
-                      EC &spe);
+    PageDict4SPWriter(SSWriter &sparseSparsewriter, EC &spe);
 
     ~PageDict4SPWriter();
+    void setup();
+    void flushPage();
+    void flush();
+    void resetPage();
+    void addL3Skip(vespalib::stringref word, const StartOffset &startOffset, uint64_t wordNum, uint64_t pageNum);
+    void addL4Skip(size_t &lcp);
+    void addL5Skip(size_t &lcp);
 
-    void
-    setup();
-
-    void
-    flushPage();
-
-    void
-    flush();
-
-    void
-    resetPage();
-
-    void
-    addL3Skip(vespalib::stringref word,
-              const StartOffset &startOffset,
-              uint64_t wordNum,
-              uint64_t pageNum);
-
-
-    void
-    addL4Skip(size_t &lcp);
-
-    void
-    addL5Skip(size_t &lcp);
-
-    bool
-    empty() const
-    {
-        return _l3Entries == 0;
-    }
-
-    uint32_t
-    getSparsePageNum() const
-    {
-        return _sparsePageNum;
-    }
+    bool empty() const { return _l3Entries == 0; }
+    uint32_t getSparsePageNum() const { return _sparsePageNum; }
 
     /*
      * Add overflow counts entry.
      *
      * startOffset represents file position / accNumDocs at start of entry.
      */
-    void
-    addOverflowCounts(vespalib::stringref word,
-                      const Counts &counts,
-                      const StartOffset &startOffset,
-                      uint64_t wordNum)
+    void addOverflowCounts(vespalib::stringref word, const Counts &counts, const StartOffset &startOffset, uint64_t wordNum)
     {
         _ssWriter.addOverflowCounts(word, counts, startOffset, wordNum);
     }
@@ -385,50 +352,19 @@ private:
                       const Counts &counts);
 
 public:
-    PageDict4PWriter(SPWriter &spWriter,
-                     EC &pe);
-
+    PageDict4PWriter(SPWriter &spWriter, EC &pe);
     ~PageDict4PWriter();
 
-    void
-    setup();
-
-    void
-    flushPage();
-
-    void
-    flush();
-
-    void
-    resetPage();
-
-    void
-    addCounts(vespalib::stringref word,
-              const Counts &counts);
-
-    void
-    addL1Skip(size_t &lcp);
-
-    void
-    addL2Skip(size_t &lcp);
-
-    bool
-    empty() const
-    {
-        return _countsEntries == 0;
-    }
-
-    uint64_t
-    getPageNum() const
-    {
-        return _pageNum;
-    }
-
-    uint64_t
-    getWordNum() const
-    {
-        return _wordNum - 1;
-    }
+    void setup();
+    void flushPage();
+    void flush();
+    void resetPage();
+    void addCounts(vespalib::stringref word, const Counts &counts);
+    void addL1Skip(size_t &lcp);
+    void addL2Skip(size_t &lcp);
+    bool empty() const { return _countsEntries == 0;}
+    uint64_t getPageNum() const { return _pageNum; }
+    uint64_t getWordNum() const { return _wordNum - 1; }
 };
 
 
@@ -450,7 +386,6 @@ public:
     bool _overflow;
 
     PageDict4SSLookupRes();
-
     ~PageDict4SSLookupRes();
 };
 
@@ -505,9 +440,7 @@ public:
         {
         }
 
-        bool
-        operator<(vespalib::stringref word) const
-        {
+        bool operator<(vespalib::stringref word) const {
             return _l7Word < word;
         }
     };
@@ -530,9 +463,7 @@ public:
         {
         }
 
-        bool
-        operator<(uint64_t wordNum) const
-        {
+        bool operator<(uint64_t wordNum) const {
             return _wordNum < wordNum;
         }
     };
@@ -564,23 +495,12 @@ public:
                       uint64_t spFileBitLen,
                       uint32_t pFileHeaderSize,
                       uint64_t pFileBitLen);
-
     ~PageDict4SSReader();
 
-    void
-    setup(DC &ssd);
-
-    PageDict4SSLookupRes
-    lookup(vespalib::stringref key);
-
-    PageDict4SSLookupRes
-    lookupOverflow(uint64_t wordNum) const;
-
-    const DC &
-    getSSD() const
-    {
-        return _ssd;
-    }
+    void setup(DC &ssd);
+    PageDict4SSLookupRes lookup(vespalib::stringref key);
+    PageDict4SSLookupRes lookupOverflow(uint64_t wordNum) const;
+    const DC & getSSD() const { return _ssd; }
 };
 
 
@@ -630,7 +550,6 @@ public:
 
 public:
     PageDict4PLookupRes();
-
     ~PageDict4PLookupRes();
 
     bool
@@ -735,20 +654,15 @@ public:
             : _vector(),
               _cur(),
               _end()
-        {
-        }
-        void clear() {
-            _vector.clear();
-        }
+        {}
+        void clear() { _vector.clear(); }
         void setup() {
             _cur = _vector.cbegin();
             _end = _vector.cend();
         }
         bool valid() const { return _cur != _end; }
         const Element *operator->() const { return _cur.operator->(); }
-        void step() {
-            ++_cur;
-        }
+        void step() { ++_cur; }
         void push_back(const Element &element) {
             _vector.push_back(element);
         }
@@ -782,39 +696,17 @@ public:
     CheckVector<L4SkipCheck> _l4SkipChecks;
     CheckVector<L5SkipCheck> _l5SkipChecks;
 
-
-    PageDict4Reader(const SSReader &ssReader,
-                    DC &spd,
-                    DC &pd);
-
+    PageDict4Reader(const SSReader &ssReader, DC &spd,DC &pd);
     ~PageDict4Reader();
 
-    void
-    setup();
-
-    void
-    setupPage();
-
-    void
-    setupSPage();
-
-    void
-    decodePWord(vespalib::string &word);
-
-    void
-    decodeSPWord(vespalib::string &word);
-
-    void
-    decodeSSWord(vespalib::string &word);
-
-    void
-    readCounts(vespalib::string &word,
-               uint64_t &wordNum,
-               Counts &counts);
-
-    void
-    readOverflowCounts(vespalib::string &word,
-                       Counts &counts);
+    void setup();
+    void setupPage();
+    void setupSPage();
+    void decodePWord(vespalib::string &word);
+    void decodeSPWord(vespalib::string &word);
+    void decodeSSWord(vespalib::string &word);
+    void readCounts(vespalib::string &word, uint64_t &wordNum, Counts &counts);
+    void readOverflowCounts(vespalib::string &word, Counts &counts);
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/bitcompression/posocccompression.cpp b/searchlib/src/vespa/searchlib/bitcompression/posocccompression.cpp
index 30c3ac4a7d2..a2b19c8d8b0 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/posocccompression.cpp
+++ b/searchlib/src/vespa/searchlib/bitcompression/posocccompression.cpp
@@ -3,7 +3,6 @@
 #include "compression.h"
 #include "posocccompression.h"
 #include "posocc_fields_params.h"
-#include <vespa/searchlib/index/schemautil.h>
 #include <vespa/searchlib/fef/termfieldmatchdata.h>
 #include <vespa/searchlib/fef/termfieldmatchdataarray.h>
 #include <vespa/vespalib/stllike/asciistream.h>
@@ -14,7 +13,6 @@ LOG_SETUP(".posocccompression");
 
 using search::index::DocIdAndFeatures;
 using search::index::PostingListParams;
-using search::index::SchemaUtil;
 using search::index::Schema;
 using search::fef::TermFieldMatchData;
 using vespalib::GenericHeader;
diff --git a/searchlib/src/vespa/searchlib/bitcompression/posocccompression.h b/searchlib/src/vespa/searchlib/bitcompression/posocccompression.h
index 46f5e2864c0..03f2e223f14 100644
--- a/searchlib/src/vespa/searchlib/bitcompression/posocccompression.h
+++ b/searchlib/src/vespa/searchlib/bitcompression/posocccompression.h
@@ -4,24 +4,13 @@
 #include <vespa/searchlib/index/docidandfeatures.h>
 #include <vespa/searchcommon/common/schema.h>
 
-
-#define K_VALUE_POSOCC_FIRST_DOCID 22
-#define MAXRICE2_POSOCC_FIRST_DOCID MAX_RICE2VAL_L32_K22
-
-#define K_VALUE_POSOCC_DELTA_DOCID 7
-#define MAXRICE2_POSOCC_DELTA_DOCID MAX_RICE2VAL_L30_K7
-
 #define K_VALUE_POSOCC_FIRST_WORDPOS 8
-#define MAXRICE2_POSOCC_FIRST_WORDPOS MAX_RICE2VAL_L32_K8
 
 #define K_VALUE_POSOCC_DELTA_WORDPOS 4
-#define MAXRICE2_POSOCC_DELTA_WORDPOS MAX_RICE2VAL_L31_K4
 
 // Compression parameters for EGPosOcc encode/decode context
 #define K_VALUE_POSOCC_ELEMENTLEN 9
 #define K_VALUE_POSOCC_NUMPOSITIONS 0
-#define K_VALUE_POSOCC_NUMFIELDS 0
-#define K_VALUE_POSOCC_FIELDID 0
 
 #define K_VALUE_POSOCC_NUMELEMENTS 0
 #define K_VALUE_POSOCC_ELEMENTID 0
diff --git a/searchlib/src/vespa/searchlib/diskindex/zc4_posting_writer.cpp b/searchlib/src/vespa/searchlib/diskindex/zc4_posting_writer.cpp
index 58916b2cfac..6d8a97df6c6 100644
--- a/searchlib/src/vespa/searchlib/diskindex/zc4_posting_writer.cpp
+++ b/searchlib/src/vespa/searchlib/diskindex/zc4_posting_writer.cpp
@@ -21,9 +21,7 @@ Zc4PostingWriter<bigEndian>::Zc4PostingWriter(PostingListCounts &counts)
 }
 
 template <bool bigEndian>
-Zc4PostingWriter<bigEndian>::~Zc4PostingWriter()
-{
-}
+Zc4PostingWriter<bigEndian>::~Zc4PostingWriter() = default;
 
 template <bool bigEndian>
 void
@@ -122,9 +120,7 @@ Zc4PostingWriter<bigEndian>::flush_word_with_skip(bool hasMore)
     }
 
     // Write features
-    e.writeBits(static_cast<const uint64_t *>(_featureWriteContext._comprBuf),
-                0,
-                _featureOffset);
+    e.writeBits(_featureWriteContext.getComprBuf(), 0, _featureOffset);
 
     _counts._numDocs += numDocs;
     if (hasMore || !_counts._segments.empty()) {
@@ -179,8 +175,7 @@ Zc4PostingWriter<bigEndian>::flush_word_no_skip()
     uint32_t docIdK = _dynamicK ? e.calcDocIdK(numDocs, _docIdLimit) : K_VALUE_ZCPOSTING_DELTA_DOCID;
 
     uint32_t baseDocId = 1;
-    const uint64_t *features =
-        static_cast<const uint64_t *>(_featureWriteContext._comprBuf);
+    const uint64_t *features = _featureWriteContext.getComprBuf();
     uint64_t featureOffset = 0;
 
     std::vector<DocIdAndFeatureSize>::const_iterator dit = _docIds.begin();
diff --git a/searchlib/src/vespa/searchlib/test/diskindex/pagedict4_mem_rand_reader.cpp b/searchlib/src/vespa/searchlib/test/diskindex/pagedict4_mem_rand_reader.cpp
index fdee620d12d..736a147c1ce 100644
--- a/searchlib/src/vespa/searchlib/test/diskindex/pagedict4_mem_rand_reader.cpp
+++ b/searchlib/src/vespa/searchlib/test/diskindex/pagedict4_mem_rand_reader.cpp
@@ -12,8 +12,8 @@ PageDict4MemRandReader::PageDict4MemRandReader(uint32_t chunkSize, uint64_t numW
            wb._ssHeaderLen, wb._ssFileBitSize,
            wb._spHeaderLen, wb._spFileBitSize,
            wb._pHeaderLen, wb._pFileBitSize),
-      _spData(static_cast<const char *>(_buffers._rcspd._comprBuf)),
-      _pData(static_cast<const char *>(_buffers._rcpd._comprBuf)),
+      _spData(reinterpret_cast<const char *>(_buffers._rcspd.getComprBuf())),
+      _pData(reinterpret_cast<const char *>(_buffers._rcpd.getComprBuf())),
       _pageSize(search::bitcompression::PageDict4PageParams::getPageByteSize())
 {
     _ssr.setup(_decoders.ssd);
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.cpp b/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.cpp
index 87ca9754b95..a6abdc4d788 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.cpp
+++ b/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.cpp
@@ -1,6 +1,5 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include "bitencode64.h"
 #include "bitdecode64.h"
 
 namespace search::fakedata {
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.h b/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.h
index 208cc22cdc3..7f1403002b5 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.h
+++ b/searchlib/src/vespa/searchlib/test/fakedata/bitdecode64.h
@@ -5,11 +5,7 @@
 #include <vespa/searchlib/util/comprfile.h>
 #include <vespa/searchlib/bitcompression/compression.h>
 
-namespace search
-{
-
-namespace fakedata
-{
+namespace search::fakedata {
 
 template <bool bigEndian>
 class BitDecode64 : public bitcompression::DecodeContext64<bigEndian>
@@ -26,8 +22,7 @@ public:
     using ParentClass::_cacheInt;
     typedef typename bitcompression::DecodeContext64<bigEndian>::EC EC;
 
-    BitDecode64(const uint64_t *compr,
-                  int bitOffset)
+    BitDecode64(const uint64_t *compr, int bitOffset)
         : bitcompression::DecodeContext64<bigEndian>(compr, bitOffset),
           _comprBase(compr),
           _bitOffsetBase(bitOffset)
@@ -36,9 +31,7 @@ public:
 
     typedef bitcompression::DecodeContext64<bigEndian> DC;
 
-    void
-    seek(uint64_t offset)
-    {
+    void seek(uint64_t offset) {
         offset += _bitOffsetBase;
         const uint64_t *compr = _comprBase + (offset / 64);
         int bitOffset = offset & 63;
@@ -50,42 +43,22 @@ public:
         UC64_READBITS(_val, _valI, _preRead, _cacheInt, EC);
     }
 
-    uint64_t
-    getOffset() const
-    {
-        return 64 * (_valI - _comprBase - 1) - this->_preRead -
-            _bitOffsetBase;
+    uint64_t getOffset() const {
+        return 64 * (_valI - _comprBase - 1) - this->_preRead - _bitOffsetBase;
     }
 
-    uint64_t
-    getOffset(const uint64_t *valI, int preRead) const
-    {
+    uint64_t getOffset(const uint64_t *valI, int preRead) const {
         return 64 * (valI - _comprBase - 1) - preRead - _bitOffsetBase;
     }
 
-    const uint64_t *
-    getComprBase() const
-    {
-        return _comprBase;
-    }
-
-    int
-    getBitOffsetBase() const
-    {
-        return _bitOffsetBase;
-    }
+    const uint64_t * getComprBase() const { return _comprBase; }
+    int getBitOffsetBase() const { return _bitOffsetBase; }
 };
 
 
 extern template class BitDecode64<true>;
-
 extern template class BitDecode64<false>;
 
 typedef BitDecode64<true> BitDecode64BE;
 
-typedef BitDecode64<false> BitDecode64LE;
-
-} // namespace fakedata
-
-} // namespace search
-
+}
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.cpp b/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.cpp
index 9f1a4a7bb23..69c7edc01b8 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.cpp
+++ b/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.cpp
@@ -14,9 +14,7 @@ BitEncode64<bigEndian>::BitEncode64()
 }
 
 template <bool bigEndian>
-BitEncode64<bigEndian>::~BitEncode64()
-{
-}
+BitEncode64<bigEndian>::~BitEncode64() = default;
 
 template class BitEncode64<true>;
 template class BitEncode64<false>;
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.h b/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.h
index 288d12973e5..ffddc4d7be7 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.h
+++ b/searchlib/src/vespa/searchlib/test/fakedata/bitencode64.h
@@ -5,11 +5,7 @@
 #include <vespa/searchlib/bitcompression/compression.h>
 #include <vespa/searchlib/util/comprfile.h>
 
-namespace search
-{
-
-namespace fakedata
-{
+namespace search::fakedata {
 
 template <bool bigEndian>
 class BitEncode64 : public bitcompression::EncodeContext64<bigEndian>
@@ -18,20 +14,15 @@ class BitEncode64 : public bitcompression::EncodeContext64<bigEndian>
 
 public:
     BitEncode64();
-
     ~BitEncode64();
 
     typedef bitcompression::EncodeContext64<bigEndian> EC;
 
-    void
-    writeComprBuffer()
-    {
+    void writeComprBuffer() {
         _cbuf.writeComprBuffer(true);
     }
 
-    void
-    writeComprBufferIfNeeded()
-    {
+    void writeComprBufferIfNeeded() {
         if (this->_valI >= this->_valE)
             _cbuf.writeComprBuffer(false);
     }
@@ -40,20 +31,11 @@ public:
     grabComprBuffer(void *&comprBufMalloc)
     {
         std::pair<void *, size_t> tres = _cbuf.grabComprBuffer(comprBufMalloc);
-        return std::make_pair(static_cast<uint64_t *>(tres.first),
-                              tres.second);
+        return std::make_pair(static_cast<uint64_t *>(tres.first), tres.second);
     }
 };
 
 extern template class BitEncode64<true>;
-
 extern template class BitEncode64<false>;
 
-typedef BitEncode64<true> BitEncode64BE;
-
-typedef BitEncode64<false> BitEncode64LE;
-
-} // namespace fakedata
-
-} // namespace search
-
+}
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.cpp b/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.cpp
index 04aa790e4cb..795e25899c0 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.cpp
+++ b/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.cpp
@@ -1,9 +1,10 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "fakeegcompr64filterocc.h"
+#include "bitencode64.h"
+#include "bitdecode64.h"
 #include "fpfactory.h"
 #include <vespa/searchlib/queryeval/iterators.h>
-#include <vespa/vespalib/util/stringfmt.h>
 
 #include <vespa/log/log.h>
 LOG_SETUP(".searchlib.test.fake_eg_compr64_filter_occ");
@@ -11,9 +12,6 @@ LOG_SETUP(".searchlib.test.fake_eg_compr64_filter_occ");
 using search::fef::TermFieldMatchData;
 using search::fef::TermFieldMatchDataPosition;
 
-#include "bitencode64.h"
-#include "bitdecode64.h"
-
 namespace search::fakedata {
 
 #define DEBUG_EGCOMPR64FILTEROCC_PRINTF 0
@@ -612,7 +610,7 @@ private:
     typedef BitDecode64<bigEndian> DC;
 
 public:
-    DC _docIdBits;
+    DC       _docIdBits;
     uint32_t _residue;
     uint32_t _lastDocId;
 
@@ -764,9 +762,7 @@ FakeEGCompr64LEFilterOcc::FakeEGCompr64LEFilterOcc(const FakeWord &fw)
 }
 
 
-FakeEGCompr64LEFilterOcc::~FakeEGCompr64LEFilterOcc()
-{
-}
+FakeEGCompr64LEFilterOcc::~FakeEGCompr64LEFilterOcc() = default;
 
 
 static FPFactoryInit
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.h b/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.h
index 096fe332483..1d84082e446 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.h
+++ b/searchlib/src/vespa/searchlib/test/fakedata/fakeegcompr64filterocc.h
@@ -4,9 +4,7 @@
 #include "fakeword.h"
 #include "fakeposting.h"
 
-namespace search {
-
-namespace fakedata {
+namespace search::fakedata {
 
 /*
  * Old compressed posocc format.
@@ -62,6 +60,4 @@ public:
     queryeval::SearchIterator *createIterator(const fef::TermFieldMatchDataArray &matchData) const override;
 };
 
-} // namespace fakedata
-
-} // namespace search
+}
diff --git a/searchlib/src/vespa/searchlib/test/fakedata/fakezcfilterocc.cpp b/searchlib/src/vespa/searchlib/test/fakedata/fakezcfilterocc.cpp
index d6c8ffc5caf..1da086fb046 100644
--- a/searchlib/src/vespa/searchlib/test/fakedata/fakezcfilterocc.cpp
+++ b/searchlib/src/vespa/searchlib/test/fakedata/fakezcfilterocc.cpp
@@ -26,9 +26,7 @@ using search::bitcompression::FeatureEncodeContext;
 using search::ComprFileWriteContext;
 using namespace search::diskindex;
 
-namespace search {
-
-namespace fakedata {
+namespace search::fakedata {
 
 namespace {
 
@@ -97,8 +95,8 @@ FakeZcFilterOcc::FakeZcFilterOcc(const FakeWord &fw)
       _hitDocs(0),
       _lastDocId(0u),
       _compressedBits(0),
-      _compressed(std::make_pair(static_cast<uint64_t *>(NULL), 0)),
-      _compressedMalloc(NULL),
+      _compressed(std::make_pair(static_cast<uint64_t *>(nullptr), 0)),
+      _compressedMalloc(nullptr),
       _featuresSize(0),
       _fieldsParams(fw.getFieldsParams()),
       _bigEndian(true),
@@ -121,7 +119,7 @@ FakeZcFilterOcc::FakeZcFilterOcc(const FakeWord &fw,
       _hitDocs(0),
       _lastDocId(0u),
       _compressedBits(0),
-      _compressed(std::make_pair(static_cast<uint64_t *>(NULL), 0)),
+      _compressed(std::make_pair(static_cast<uint64_t *>(nullptr), 0)),
       _featuresSize(0),
       _fieldsParams(fw.getFieldsParams()),
       _bigEndian(bigEndian),
@@ -204,8 +202,7 @@ FakeZcFilterOcc::setupT(const FakeWord &fw)
     writer.on_close();
 
     std::pair<void *, size_t> ectxData = writeContext.grabComprBuffer(_compressedMalloc);
-    _compressed = std::make_pair(static_cast<uint64_t *>(ectxData.first),
-                                 ectxData.second);
+    _compressed = std::make_pair(static_cast<uint64_t *>(ectxData.first), ectxData.second);
     read_header<bigEndian>();
 }
 
@@ -430,7 +427,7 @@ FakeFilterOccZCArrayIterator(const uint64_t *compressed,
                              uint32_t docIdLimit,
                              const fef::TermFieldMatchDataArray &matchData)
     : queryeval::RankedSearchIteratorBase(matchData),
-      _valI(NULL),
+      _valI(nullptr),
       _residue(0),
       _lastDocId(0),
       _decodeContext(compressed, bitOffset),
@@ -956,7 +953,4 @@ static FPFactoryInit
 initNoSkipPoslecf(std::make_pair("Zc5NoSkipPosOccLE.cf",
                                  makeFPFactory<FPFactoryT<FakeZc5NoSkipPosOccCf<false> > >));
 
-
-} // namespace fakedata
-
-} // namespace search
+}
diff --git a/searchlib/src/vespa/searchlib/util/comprbuffer.cpp b/searchlib/src/vespa/searchlib/util/comprbuffer.cpp
index acfc2e46020..9b122419267 100644
--- a/searchlib/src/vespa/searchlib/util/comprbuffer.cpp
+++ b/searchlib/src/vespa/searchlib/util/comprbuffer.cpp
@@ -8,10 +8,11 @@
 namespace search {
 
 ComprBuffer::ComprBuffer(uint32_t unitSize)
-    : _comprBuf(NULL),
+    : _unitSize(unitSize),
+      _padBefore(false),
+      _comprBuf(nullptr),
       _comprBufSize(0),
-      _unitSize(unitSize),
-      _comprBufMalloc(NULL)
+      _comprBufMalloc(nullptr)
 { }
 
 
@@ -25,8 +26,8 @@ void
 ComprBuffer::dropComprBuf()
 {
     free(_comprBufMalloc);
-    _comprBuf = NULL;
-    _comprBufMalloc = NULL;
+    _comprBuf = nullptr;
+    _comprBufMalloc = nullptr;
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/util/comprbuffer.h b/searchlib/src/vespa/searchlib/util/comprbuffer.h
index c15671d5e14..679c0dccdf0 100644
--- a/searchlib/src/vespa/searchlib/util/comprbuffer.h
+++ b/searchlib/src/vespa/searchlib/util/comprbuffer.h
@@ -10,13 +10,13 @@ class ComprBuffer
 {
 private:
     void allocComprBuf();
+    const uint32_t   _unitSize; // Size of unit in bytes, doubles up as alignment
+    bool             _padBefore;
+    void            *_comprBuf;
+    size_t           _comprBufSize;
+    void            *_comprBufMalloc;
+    FileAlign        _aligner;
 public:
-    void *_comprBuf;
-    size_t _comprBufSize;
-    uint32_t _unitSize; // Size of unit in bytes, doubles up as alignment
-    bool _padBefore;
-    void *_comprBufMalloc;
-    FileAlign _aligner;
 
     ComprBuffer(const ComprBuffer &) = delete;
     ComprBuffer &operator=(const ComprBuffer &) = delete;
@@ -30,7 +30,26 @@ public:
 
     static size_t minimumPadding() { return 8; }
     uint32_t getUnitBitSize() const { return _unitSize * 8; }
-    bool getPadBefore() const { return _padBefore; }
+    uint32_t getUnitSize() const { return _unitSize; }
+    const uint64_t * getComprBuf() const { return static_cast<const uint64_t *>(_comprBuf); }
+    uint64_t * getComprBuf() { return static_cast<uint64_t *>(_comprBuf); }
+    size_t getComprBufSize() const { return _comprBufSize; }
+    void setComprBuf(void * buf, size_t sz) {
+        _comprBuf = buf;
+        _comprBufSize = sz;
+    }
+
+    const uint64_t * getAdjustedBuf(size_t offset) const {
+        return getComprBuf() + _aligner.adjustElements(offset / sizeof(uint64_t),getComprBufSize());
+    }
+    const FileAlign & getAligner() const { return _aligner; }
+
+    void * stealComprBuf() {
+        void * stolen = _comprBufMalloc;
+        _comprBufMalloc = nullptr;
+        setComprBuf(nullptr, 0);
+        return stolen;
+    }
 
     /*
      * When encoding to memory instead of file, the compressed buffer must
diff --git a/searchlib/src/vespa/searchlib/util/comprfile.cpp b/searchlib/src/vespa/searchlib/util/comprfile.cpp
index 400a93acd26..b0099ad9074 100644
--- a/searchlib/src/vespa/searchlib/util/comprfile.cpp
+++ b/searchlib/src/vespa/searchlib/util/comprfile.cpp
@@ -17,7 +17,7 @@ ComprFileReadBase::ReadComprBuffer(uint64_t stopOffset,
                                    uint64_t fileSize,
                                    ComprBuffer &cbuf)
 {
-    assert(cbuf._comprBuf != NULL);
+    assert(cbuf.getComprBuf() != nullptr);
 
     bool isretryread = false;
 
@@ -33,13 +33,13 @@ ComprFileReadBase::ReadComprBuffer(uint64_t stopOffset,
 
     // Assert that file read offset is aligned on unit boundary
     assert((static_cast<size_t>(fileReadByteOffset) &
-            (cbuf._unitSize - 1)) == 0);
+            (cbuf.getUnitSize() - 1)) == 0);
     // Get direct IO file alignment
-    size_t fileDirectIOAlign = cbuf._aligner.getDirectIOFileAlign();
+    size_t fileDirectIOAlign = cbuf.getAligner().getDirectIOFileAlign();
     // calculate number of pad units before requested start
     int padBeforeUnits = static_cast<int>
                          (static_cast<size_t>(fileReadByteOffset) &
-                          (fileDirectIOAlign - 1)) / cbuf._unitSize;
+                          (fileDirectIOAlign - 1)) / cbuf.getUnitSize();
     // No padding before if at end of file.
     if (fileReadByteOffset >= fileSize)
         padBeforeUnits = 0;
@@ -67,9 +67,8 @@ ComprFileReadBase::ReadComprBuffer(uint64_t stopOffset,
     int64_t readBits = static_cast<int64_t>(stopOffset) -
                        (static_cast<int64_t>(fileReadByteOffset) << 3) +
                        padBeforeUnits * cbuf.getUnitBitSize();
-    int64_t bufferBits = cbuf._comprBufSize * cbuf.getUnitBitSize();
-    if (readBits > 0 && (bufferBits < readBits))
-    {
+    int64_t bufferBits = cbuf.getComprBufSize() * cbuf.getUnitBitSize();
+    if (readBits > 0 && (bufferBits < readBits)) {
         isMore = true;
         readBits = bufferBits;
     }
@@ -82,15 +81,15 @@ ComprFileReadBase::ReadComprBuffer(uint64_t stopOffset,
     }
     // Move remaining integers to padding area before start of buffer
     if (remainingUnits + extraRemainingUnits > 0)
-        memmove(static_cast<char *>(cbuf._comprBuf) -
-                (remainingUnits + extraRemainingUnits) * cbuf._unitSize,
+        memmove(reinterpret_cast<char *>(cbuf.getComprBuf()) -
+                (remainingUnits + extraRemainingUnits) * cbuf.getUnitSize(),
                 static_cast<const char *>(decodeContext.getUnitPtr()) -
-                extraRemainingUnits * cbuf._unitSize,
-                (remainingUnits + extraRemainingUnits) * cbuf._unitSize);
+                extraRemainingUnits * cbuf.getUnitSize(),
+                (remainingUnits + extraRemainingUnits) * cbuf.getUnitSize());
 
     // Adjust file position to direct IO boundary if needed before read
     if (padBeforeUnits != 0) {
-        fileReadByteOffset -= padBeforeUnits * cbuf._unitSize;
+        fileReadByteOffset -= padBeforeUnits * cbuf.getUnitSize();
         file.SetPosition(fileReadByteOffset);
     }
     int readUnits0 = 0;
@@ -99,43 +98,41 @@ ComprFileReadBase::ReadComprBuffer(uint64_t stopOffset,
                                       cbuf.getUnitBitSize());
 
     // Try to align end of read to an alignment boundary
-    int readUnits = cbuf._aligner.adjustElements(fileReadByteOffset /
-            cbuf._unitSize, readUnits0);
+    int readUnits = cbuf.getAligner().adjustElements(fileReadByteOffset /
+            cbuf.getUnitSize(), readUnits0);
     if (readUnits < readUnits0)
         isMore = true;
 
     if (readUnits > 0) {
         int64_t padBytes = fileReadByteOffset +
-                           static_cast<int64_t>(readUnits) * cbuf._unitSize -
-                           fileSize;
+                           static_cast<int64_t>(readUnits) * cbuf.getUnitSize() - fileSize;
         if (!isMore && padBytes > 0) {
             // Pad reading of file written with smaller unit size with
             // NUL bytes.
-            file.ReadBuf(cbuf._comprBuf, readUnits * cbuf._unitSize -
-                         padBytes);
-            memset(static_cast<char *>(cbuf._comprBuf) +
-                   readUnits * cbuf._unitSize - padBytes,
+            file.ReadBuf(cbuf.getComprBuf(), readUnits * cbuf.getUnitSize() - padBytes);
+            memset(reinterpret_cast<char *>(cbuf.getComprBuf()) +
+                   readUnits * cbuf.getUnitSize() - padBytes,
                    0,
                    padBytes);
         } else
-            file.ReadBuf(cbuf._comprBuf, readUnits * cbuf._unitSize);
+            file.ReadBuf(cbuf.getComprBuf(), readUnits * cbuf.getUnitSize());
     }
     // If at end of file then add units of zero bits as padding
     if (!isMore)
-        memset(static_cast<char *>(cbuf._comprBuf) +
-               readUnits * cbuf._unitSize,
+        memset(reinterpret_cast<char *>(cbuf.getComprBuf()) +
+               readUnits * cbuf.getUnitSize(),
                0,
-               cbuf._unitSize * ComprBuffer::minimumPadding());
+               cbuf.getUnitSize() * ComprBuffer::minimumPadding());
 
     assert(remainingUnits + readUnits >= 0);
-    decodeContext.afterRead(static_cast<char *>(cbuf._comprBuf) +
+    decodeContext.afterRead(reinterpret_cast<char *>(cbuf.getComprBuf()) +
                             (padBeforeUnits - remainingUnits) *
-                            static_cast<int32_t>(cbuf._unitSize),
+                            static_cast<int32_t>(cbuf.getUnitSize()),
                             (remainingUnits + readUnits - padBeforeUnits),
                             fileReadByteOffset +
-                            readUnits * cbuf._unitSize,
+                            readUnits * cbuf.getUnitSize(),
                             isMore);
-    fileReadByteOffset += readUnits * cbuf._unitSize;
+    fileReadByteOffset += readUnits * cbuf.getUnitSize();
     if (!isretryread &&
         decodeContext.endOfChunk() &&
         isMore) {
@@ -217,7 +214,7 @@ ComprFileReadBase::SetPosition(uint64_t newPosition,
         return;
     }
     pos = newPosition / cbuf.getUnitBitSize();
-    pos *= cbuf._unitSize;
+    pos *= cbuf.getUnitSize();
     fileReadByteOffset = pos;
     bitOffset = static_cast<int>(static_cast<uint32_t>(newPosition) &
                                  (cbuf.getUnitBitSize() - 1));
@@ -233,7 +230,6 @@ ComprFileReadBase::SetPosition(uint64_t newPosition,
     assert(decodeContext.getBitPosV() == newPosition);
 }
 
-
 void
 ComprFileWriteBase::
 WriteComprBuffer(ComprFileEncodeContext &encodeContext,
@@ -242,13 +238,13 @@ WriteComprBuffer(ComprFileEncodeContext &encodeContext,
                  uint64_t &fileWriteByteOffset,
                  bool flushSlack)
 {
-    assert(cbuf._comprBuf != NULL);
+    assert(cbuf.getComprBuf() != nullptr);
 
-    int chunkUsedUnits = encodeContext.getUsedUnits(cbuf._comprBuf);
+    int chunkUsedUnits = encodeContext.getUsedUnits(cbuf.getComprBuf());
 
     if (chunkUsedUnits == 0)
         return;
-    int chunkSizeNormalMax = encodeContext.getNormalMaxUnits(cbuf._comprBuf);
+    int chunkSizeNormalMax = encodeContext.getNormalMaxUnits(cbuf.getComprBuf());
     int chunksize = chunkUsedUnits;
     /*
      * Normally, only flush the normal buffer and copy the slack
@@ -256,11 +252,11 @@ WriteComprBuffer(ComprFileEncodeContext &encodeContext,
      */
     if (!flushSlack && chunksize > chunkSizeNormalMax)
         chunksize = chunkSizeNormalMax;
-    assert(static_cast<unsigned int>(chunksize) <= cbuf._comprBufSize ||
+    assert(static_cast<unsigned int>(chunksize) <= cbuf.getComprBufSize() ||
                  (flushSlack &&
-                  static_cast<unsigned int>(chunksize) <= cbuf._comprBufSize +
+                  static_cast<unsigned int>(chunksize) <= cbuf.getComprBufSize() +
                   ComprBuffer::minimumPadding()));
-    file.WriteBuf(cbuf._comprBuf, cbuf._unitSize * chunksize);
+    file.WriteBuf(cbuf.getComprBuf(), cbuf.getUnitSize() * chunksize);
 
     int remainingUnits = chunkUsedUnits - chunksize;
     assert(remainingUnits == 0 ||
@@ -269,17 +265,14 @@ WriteComprBuffer(ComprFileEncodeContext &encodeContext,
             ComprBuffer::minimumPadding()));
     // Copy any slack after buffer to the start of the buffer
     if (remainingUnits > 0)
-        memmove(cbuf._comprBuf,
-                static_cast<char *>(cbuf._comprBuf) +
-                chunksize * cbuf._unitSize,
-                cbuf._unitSize * remainingUnits);
-
-    fileWriteByteOffset += chunksize * cbuf._unitSize;
-    encodeContext.afterWrite(cbuf,
-                             remainingUnits,
-                             fileWriteByteOffset);
-}
+        memmove(cbuf.getComprBuf(),
+                reinterpret_cast<const char *>(cbuf.getComprBuf()) +
+                chunksize * cbuf.getUnitSize(),
+                cbuf.getUnitSize() * remainingUnits);
 
+    fileWriteByteOffset += chunksize * cbuf.getUnitSize();
+    encodeContext.afterWrite(cbuf, remainingUnits, fileWriteByteOffset);
+}
 
 ComprFileReadContext::
 ComprFileReadContext(ComprFileDecodeContext &decodeContext)
@@ -290,29 +283,24 @@ ComprFileReadContext(ComprFileDecodeContext &decodeContext)
       _bitOffset(0),
       _stopOffset(0),
       _readAll(true),
-      _file(NULL)
+      _file(nullptr)
 {
 }
 
-
 ComprFileReadContext::
 ComprFileReadContext(uint32_t unitSize)
     : ComprBuffer(unitSize),
-      _decodeContext(NULL),
+      _decodeContext(nullptr),
       _fileSize(0),
       _fileReadByteOffset(0),
       _bitOffset(0),
       _stopOffset(0),
       _readAll(true),
-      _file(NULL)
-{
-}
-
-
-ComprFileReadContext::~ComprFileReadContext()
+      _file(nullptr)
 {
 }
 
+ComprFileReadContext::~ComprFileReadContext() = default;
 
 void
 ComprFileReadContext::readComprBuffer(uint64_t stopOffset, bool readAll)
@@ -327,7 +315,6 @@ ComprFileReadContext::readComprBuffer(uint64_t stopOffset, bool readAll)
             *this);
 }
 
-
 void
 ComprFileReadContext::readComprBuffer()
 {
@@ -341,25 +328,6 @@ ComprFileReadContext::readComprBuffer()
             *this);
 }
 
-
-void
-ComprFileReadContext::setPosition(uint64_t newPosition,
-                                  uint64_t stopOffset,
-                                  bool readAll)
-{
-    setStopOffset(stopOffset, readAll);
-    search::ComprFileReadBase::SetPosition(newPosition,
-            stopOffset,
-            readAll,
-            *_decodeContext,
-            _bitOffset,
-            *_file,
-            _fileReadByteOffset,
-            _fileSize,
-            *this);
-}
-
-
 void
 ComprFileReadContext::setPosition(uint64_t newPosition)
 {
@@ -374,33 +342,29 @@ ComprFileReadContext::setPosition(uint64_t newPosition)
             *this);
 }
 
-
 void
-ComprFileReadContext::allocComprBuf(unsigned int comprBufSize,
-                                    size_t preferredFileAlignment)
+ComprFileReadContext::allocComprBuf(unsigned int comprBufSize, size_t preferredFileAlignment)
 {
-    ComprBuffer::allocComprBuf(comprBufSize, preferredFileAlignment,
-                               _file, true);
+    ComprBuffer::allocComprBuf(comprBufSize, preferredFileAlignment, _file, true);
 }
 
-
 void
 ComprFileReadContext::referenceWriteContext(const ComprFileWriteContext &rhs)
 {
     ComprFileEncodeContext *e = rhs.getEncodeContext();
     ComprFileDecodeContext *d = getDecodeContext();
 
-    assert(e != NULL);
-    int usedUnits = e->getUsedUnits(rhs._comprBuf);
+    assert(e != nullptr);
+    int usedUnits = e->getUsedUnits(rhs.getComprBuf());
     assert(usedUnits >= 0);
 
     referenceComprBuf(rhs);
-    setBufferEndFilePos(static_cast<uint64_t>(usedUnits) * _unitSize);
-    setFileSize(static_cast<uint64_t>(usedUnits) * _unitSize);
-    if (d != NULL) {
-        d->afterRead(_comprBuf,
+    setBufferEndFilePos(static_cast<uint64_t>(usedUnits) * getUnitSize());
+    setFileSize(static_cast<uint64_t>(usedUnits) * getUnitSize());
+    if (d != nullptr) {
+        d->afterRead(getComprBuf(),
                      usedUnits,
-                     static_cast<uint64_t>(usedUnits) * _unitSize,
+                     static_cast<uint64_t>(usedUnits) * getUnitSize(),
                      false);
         d->setupBits(0);
         setBitOffset(-1);
@@ -413,14 +377,13 @@ ComprFileReadContext::reference_compressed_buffer(void *buffer, size_t usedUnits
 {
     ComprFileDecodeContext *d = getDecodeContext();
 
-    _comprBuf = buffer;
-    _comprBufSize = usedUnits;
-    setBufferEndFilePos(static_cast<uint64_t>(usedUnits) * _unitSize);
-    setFileSize(static_cast<uint64_t>(usedUnits) * _unitSize);
-    if (d != NULL) {
-        d->afterRead(_comprBuf,
+    setComprBuf(buffer, usedUnits);
+    setBufferEndFilePos(static_cast<uint64_t>(usedUnits) * getUnitSize());
+    setFileSize(static_cast<uint64_t>(usedUnits) * getUnitSize());
+    if (d != nullptr) {
+        d->afterRead(getComprBuf(),
                      usedUnits,
-                     static_cast<uint64_t>(usedUnits) * _unitSize,
+                     static_cast<uint64_t>(usedUnits) * getUnitSize(),
                      false);
         d->setupBits(0);
         setBitOffset(-1);
@@ -432,31 +395,26 @@ ComprFileWriteContext::
 ComprFileWriteContext(ComprFileEncodeContext &encodeContext)
     : ComprBuffer(encodeContext.getUnitByteSize()),
       _encodeContext(&encodeContext),
-      _file(NULL),
+      _file(nullptr),
       _fileWriteByteOffset(0)
 {
 }
 
-
 ComprFileWriteContext::
 ComprFileWriteContext(uint32_t unitSize)
     : ComprBuffer(unitSize),
-      _encodeContext(NULL),
-      _file(NULL),
+      _encodeContext(nullptr),
+      _file(nullptr),
       _fileWriteByteOffset(0)
 {
 }
 
-
-ComprFileWriteContext::~ComprFileWriteContext()
-{
-}
-
+ComprFileWriteContext::~ComprFileWriteContext() = default;
 
 void
 ComprFileWriteContext::writeComprBuffer(bool flushSlack)
 {
-    if (_file != NULL) {
+    if (_file != nullptr) {
         search::ComprFileWriteBase::WriteComprBuffer(*_encodeContext,
                 *this,
                 *_file,
@@ -465,42 +423,33 @@ ComprFileWriteContext::writeComprBuffer(bool flushSlack)
         return;
     }
 
-    int chunkUsedUnits = _encodeContext->getUsedUnits(_comprBuf);
-    int chunkSizeNormalMax = _encodeContext->getNormalMaxUnits(_comprBuf);
+    int chunkUsedUnits = _encodeContext->getUsedUnits(getComprBuf());
+    int chunkSizeNormalMax = _encodeContext->getNormalMaxUnits(getComprBuf());
 
     if (chunkUsedUnits >= chunkSizeNormalMax) {
         int overflowUnits = chunkUsedUnits - chunkSizeNormalMax;
         expandComprBuf(overflowUnits);
     }
 
-    _encodeContext->afterWrite(*this,
-                               chunkUsedUnits,
-                               0);
+    _encodeContext->afterWrite(*this, chunkUsedUnits, 0);
 }
 
-
 std::pair<void *, size_t>
 ComprFileWriteContext::grabComprBuffer(void *&comprBufMalloc)
 {
-    assert(_file == NULL);
+    assert(_file == nullptr);
     std::pair<void *, size_t> res =
-        std::make_pair(_comprBuf, _encodeContext->getUsedUnits(_comprBuf));
-    comprBufMalloc = _comprBufMalloc;
-    _comprBuf = _comprBufMalloc = NULL;
-    _comprBufSize = 0;
+        std::make_pair(getComprBuf(), _encodeContext->getUsedUnits(getComprBuf()));
+    comprBufMalloc = stealComprBuf();
     return res;
 }
 
-
 void
-ComprFileWriteContext::allocComprBuf(unsigned int comprBufSize,
-                                     size_t preferredFileAlignment)
+ComprFileWriteContext::allocComprBuf(unsigned int comprBufSize, size_t preferredFileAlignment)
 {
-    ComprBuffer::allocComprBuf(comprBufSize, preferredFileAlignment,
-                               _file, false);
+    ComprBuffer::allocComprBuf(comprBufSize, preferredFileAlignment, _file, false);
 }
 
-
 void
 ComprFileWriteContext::allocComprBuf()
 {
diff --git a/searchlib/src/vespa/searchlib/util/comprfile.h b/searchlib/src/vespa/searchlib/util/comprfile.h
index 431126dee47..a28e14b02ac 100644
--- a/searchlib/src/vespa/searchlib/util/comprfile.h
+++ b/searchlib/src/vespa/searchlib/util/comprfile.h
@@ -14,7 +14,7 @@ class ComprFileWriteContext;
 class ComprFileDecodeContext
 {
 public:
-    virtual ~ComprFileDecodeContext() { }
+    virtual ~ComprFileDecodeContext() = default;
 
     /**
      *
@@ -82,7 +82,7 @@ public:
                             ComprBuffer &cbuf);
 
 protected:
-    virtual ~ComprFileReadBase() { }
+    virtual ~ComprFileReadBase() = default;
 };
 
 
@@ -104,13 +104,11 @@ public:
 
     void readComprBuffer(uint64_t stopOffset, bool readAll);
     void readComprBuffer();
-    void setPosition(uint64_t newPosition, uint64_t stopOffset, bool readAll);
     void setPosition(uint64_t newPosition);
     void allocComprBuf(unsigned int comprBufSize, size_t preferredFileAlignment);
     void setDecodeContext(ComprFileDecodeContext *decodeContext) { _decodeContext = decodeContext; }
     ComprFileDecodeContext *getDecodeContext() const { return _decodeContext; }
     void setFile(FastOS_FileInterface *file) { _file = file; }
-    FastOS_FileInterface *getFile() const { return _file; }
 
     /**
      * Get file offset for end of compressed buffer.
@@ -125,14 +123,6 @@ public:
     void setFileSize(uint64_t fileSize) { _fileSize = fileSize; }
 
     /*
-     * Set stop offset for sequential read.
-     */
-    void setStopOffset(uint64_t stopOffset, bool readAll) {
-        _stopOffset = stopOffset;
-        _readAll = readAll;
-    }
-
-    /*
      * For unit testing only. Reference data owned by rhs, only works as
      * long as rhs is live and unchanged.
      */
@@ -144,12 +134,12 @@ public:
 class ComprFileEncodeContext
 {
 public:
-    virtual ~ComprFileEncodeContext() { }
+    virtual ~ComprFileEncodeContext() = default;
 
     /**
      * Get number of used units (e.g. _valI - start)
      */
-    virtual int getUsedUnits(void *start) = 0;
+    virtual int getUsedUnits(const uint64_t * start) = 0;
 
     /**
      * Get normal full buffer size (e.g. _valE - start)
@@ -170,8 +160,6 @@ public:
      * Get size of each unit (typically 4 or 8)
      */
     virtual uint32_t getUnitByteSize() const = 0;
-
-    virtual uint64_t getBitPosV() const = 0;
 };
 
 class ComprFileWriteBase
@@ -184,7 +172,7 @@ public:
                                  bool flushSlack);
 
 protected:
-    virtual ~ComprFileWriteBase() { }
+    virtual ~ComprFileWriteBase() = default;
 };
 
 
@@ -206,7 +194,6 @@ public:
     void setEncodeContext(ComprFileEncodeContext *encodeContext) { _encodeContext = encodeContext; }
     ComprFileEncodeContext *getEncodeContext() const { return _encodeContext; }
     void setFile(FastOS_FileInterface *file) { _file = file; }
-    FastOS_FileInterface *getFile() const { return _file; }
 
     /**
      * Get file offset for start of compressed buffer.
@@ -214,11 +201,6 @@ public:
     uint64_t getBufferStartFilePos() const { return _fileWriteByteOffset; }
 
     /**
-     * Set file offset for start of compressed byffer.
-     */
-    void setBufferStartFilePos(uint64_t bufferStartFilePos) { _fileWriteByteOffset = bufferStartFilePos; }
-
-    /**
      * Grab compressed buffer from write context.  This is only legal when
      * no file is attached.
      */
diff --git a/searchlib/src/vespa/searchlib/util/filealign.cpp b/searchlib/src/vespa/searchlib/util/filealign.cpp
index b60c0492854..1a277adc113 100644
--- a/searchlib/src/vespa/searchlib/util/filealign.cpp
+++ b/searchlib/src/vespa/searchlib/util/filealign.cpp
@@ -43,11 +43,11 @@ FileAlign::FileAlign()
 { }
 
 
-FileAlign::~FileAlign() { }
+FileAlign::~FileAlign() = default;
 
 
 size_t
-FileAlign::adjustSize(int64_t offset, size_t size)
+FileAlign::adjustSize(int64_t offset, size_t size) const
 {
     if (_directio && (offset & (_directIOFileAlign - 1)) != 0) {
         // Align end of IO to direct IO boundary
@@ -68,7 +68,7 @@ FileAlign::adjustSize(int64_t offset, size_t size)
 
 
 size_t
-FileAlign::adjustElements(int64_t eoffset, size_t esize)
+FileAlign::adjustElements(int64_t eoffset, size_t esize) const
 {
     return adjustSize(eoffset * _elemSize, esize * _elemSize) / _elemSize;
 }
@@ -84,7 +84,7 @@ FileAlign::setupAlign(size_t elements,
     size_t transferGranularity;
     size_t transferMaximum;
 
-    if (file != NULL) {
+    if (file != nullptr) {
         _directio = file->GetDirectIORestrictions(memoryAlignment, transferGranularity, transferMaximum);
     } else
         _directio = false;
diff --git a/searchlib/src/vespa/searchlib/util/filealign.h b/searchlib/src/vespa/searchlib/util/filealign.h
index 49d053957ce..4b6dc2daf15 100644
--- a/searchlib/src/vespa/searchlib/util/filealign.h
+++ b/searchlib/src/vespa/searchlib/util/filealign.h
@@ -35,7 +35,7 @@ public:
      *
      * @return adjusted number of bytes for IO
      */
-    size_t adjustSize(int64_t offset, size_t size);
+    size_t adjustSize(int64_t offset, size_t size) const;
 
     /**
      * Adjust number of elements for IO (read or write), reducing
@@ -47,7 +47,7 @@ public:
      *
      * @return adjusted number of elements for IO
      */
-    size_t adjustElements(int64_t eoffset, size_t esize);
+    size_t adjustElements(int64_t eoffset, size_t esize) const;
 
     /**
      * Setup alignment
diff --git a/vespalib/src/vespa/vespalib/datastore/unique_store_enumerator.hpp b/vespalib/src/vespa/vespalib/datastore/unique_store_enumerator.hpp
index d779b2f2bd3..dbcb2c10b86 100644
--- a/vespalib/src/vespa/vespalib/datastore/unique_store_enumerator.hpp
+++ b/vespalib/src/vespa/vespalib/datastore/unique_store_enumerator.hpp
@@ -19,9 +19,7 @@ UniqueStoreEnumerator<RefT>::UniqueStoreEnumerator(const IUniqueStoreDictionary
 }
 
 template <typename RefT>
-UniqueStoreEnumerator<RefT>::~UniqueStoreEnumerator()
-{
-}
+UniqueStoreEnumerator<RefT>::~UniqueStoreEnumerator() = default;
 
 template <typename RefT>
 void