Merge pull request #18495 from vespa-engine/balder/allow-presizing-of-arrays

Balder/allow presizing of arrays

18 files changed, 100 insertions, 73 deletions

diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attributedfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/attributedfw.cpp
index b600a612bb5..d41d4e0010c 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attributedfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attributedfw.cpp
@@ -210,9 +210,9 @@ MultiAttrDFW<DataType>::insertField(uint32_t docid, GetDocsumsState* state, ResT
         return;  // Don't insert empty fields
     }
 
-    Cursor &arr = target.insertArray();
     std::vector<DataType> elements(entries);
     entries = std::min(entries, attr.get(docid, elements.data(), entries));
+    Cursor &arr = target.insertArray(entries);
 
     if (_filter_elements) {
         const auto& matching_elems = state->get_matching_elements(*_matching_elems_fields)
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp
index 6991d3acb29..aa891680a09 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp
@@ -107,7 +107,7 @@ filter_matching_elements_in_input_field(const Slime& input_field, const std::vec
 {
     SlimeInserter output_inserter(output_field);
     Inspector& input_inspector = input_field.get();
-    ArrayInserter array_inserter(output_inserter.insertArray());
+    ArrayInserter array_inserter(output_inserter.insertArray(matching_elems.size()));
     auto elems_itr = matching_elems.begin();
     for (size_t i = 0; (i < input_inspector.entries()) && (elems_itr != matching_elems.end()); ++i) {
         assert(*elems_itr >= i);
diff --git a/vespalib/src/vespa/vespalib/data/slime/array_value.cpp b/vespalib/src/vespa/vespalib/data/slime/array_value.cpp
index edcc5a8eb85..e34c352b4fd 100644
--- a/vespalib/src/vespa/vespalib/data/slime/array_value.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/array_value.cpp
@@ -7,6 +7,14 @@
 
 namespace vespalib::slime {
 
+ArrayValue::ArrayValue(SymbolTable &table, Stash & stash)
+    : _symbolTable(table),
+      _stash(stash),
+      _values()
+{}
+
+ArrayValue::~ArrayValue() = default;
+
 void
 ArrayValue::traverse(ArrayTraverser &at) const {
     for (size_t i = 0; i < _values.size(); ++i) {
@@ -16,8 +24,8 @@ ArrayValue::traverse(ArrayTraverser &at) const {
 
 
 Cursor &
-ArrayValue::addArray() {
-    return addLeaf(ArrayValueFactory(_symbolTable));
+ArrayValue::addArray(size_t reserve) {
+    return addLeaf(ArrayValueFactory(_symbolTable, reserve));
 }
 
 Cursor &
diff --git a/vespalib/src/vespa/vespalib/data/slime/array_value.h b/vespalib/src/vespa/vespalib/data/slime/array_value.h
index 19f93c3eeec..99b00b884b0 100644
--- a/vespalib/src/vespa/vespalib/data/slime/array_value.h
+++ b/vespalib/src/vespa/vespalib/data/slime/array_value.h
@@ -13,7 +13,7 @@ namespace vespalib::slime {
  * Class representing a collection of ordered values that can be
  * looked up by index.
  **/
-class ArrayValue : public Value
+class ArrayValue final : public Value
 {
 private:
     SymbolTable         &_symbolTable;
@@ -28,9 +28,10 @@ protected:
     }
 
 public:
-    ArrayValue(SymbolTable &table, Stash & stash) : _symbolTable(table), _stash(stash), _values() {}
+    ArrayValue(SymbolTable &table, Stash & stash);
     ArrayValue(const ArrayValue &) = delete;
     ArrayValue &operator=(const ArrayValue &) = delete;
+    void reserve(size_t sz) { _values.reserve(sz); }
 
     Type type() const override { return ARRAY::instance; }
     size_t children() const override { return _values.size(); }
@@ -44,11 +45,11 @@ public:
         return *NixValue::invalid();
     }
 
-    Cursor &addArray() override;
+    Cursor &addArray(size_t reserve) override;
     Cursor &addObject() override;
     Symbol resolve(Memory symbol_name) override;
 
-    ~ArrayValue() override = default;
+    ~ArrayValue() override;
 };
 
 } // namespace vespalib::slime
diff --git a/vespalib/src/vespa/vespalib/data/slime/basic_value.h b/vespalib/src/vespa/vespalib/data/slime/basic_value.h
index 3768523ada0..20183999d8f 100644
--- a/vespalib/src/vespa/vespalib/data/slime/basic_value.h
+++ b/vespalib/src/vespa/vespalib/data/slime/basic_value.h
@@ -13,33 +13,33 @@ namespace vespalib::slime {
 /**
  * Classes representing a single basic value.
  **/
-class BasicBoolValue : public Value {
+class BasicBoolValue final : public Value {
     bool _value;
 public:
-    BasicBoolValue(bool bit) : _value(bit) {}
+    BasicBoolValue(bool bit) noexcept : _value(bit) {}
     bool asBool() const override { return _value; }
     Type type() const override { return BOOL::instance; }
 };
 
-class BasicLongValue : public Value {
+class BasicLongValue final : public Value {
     int64_t _value;
 public:
-    BasicLongValue(int64_t l) : _value(l) {}
+    BasicLongValue(int64_t l) noexcept : _value(l) {}
     int64_t asLong() const override { return _value; }
     double asDouble() const override { return _value; }
     Type type() const override { return LONG::instance; }
 };
 
-class BasicDoubleValue : public Value {
+class BasicDoubleValue final : public Value {
     double _value;
 public:
-    BasicDoubleValue(double d) : _value(d) {}
+    BasicDoubleValue(double d) noexcept : _value(d) {}
     double asDouble() const override { return _value; }
     int64_t asLong() const override { return _value; }
     Type type() const override { return DOUBLE::instance; }
 };
 
-class BasicStringValue : public Value {
+class BasicStringValue final : public Value {
     Memory _value;
 public:
     BasicStringValue(Memory str, Stash & stash);
@@ -49,7 +49,7 @@ public:
     Type type() const override { return STRING::instance; }
 };
 
-class BasicDataValue : public Value {
+class BasicDataValue final : public Value {
     Memory _value;
 public:
     BasicDataValue(Memory data, Stash & stash);
diff --git a/vespalib/src/vespa/vespalib/data/slime/basic_value_factory.h b/vespalib/src/vespa/vespalib/data/slime/basic_value_factory.h
index 5562415e33e..e7b2a9dd806 100644
--- a/vespalib/src/vespa/vespalib/data/slime/basic_value_factory.h
+++ b/vespalib/src/vespa/vespalib/data/slime/basic_value_factory.h
@@ -8,33 +8,33 @@
 
 namespace vespalib::slime {
 
-struct BoolValueFactory : public ValueFactory {
+struct BoolValueFactory final : public ValueFactory {
     bool input;
-    BoolValueFactory(bool in) : input(in) {}
+    BoolValueFactory(bool in) noexcept : input(in) {}
     Value *create(Stash & stash) const override { return & stash.create<BasicBoolValue>(input); }
 };
 
-struct LongValueFactory : public ValueFactory {
+struct LongValueFactory final : public ValueFactory {
     int64_t input;
-    LongValueFactory(int64_t in) : input(in) {}
+    LongValueFactory(int64_t in) noexcept : input(in) {}
     Value *create(Stash & stash) const override { return & stash.create<BasicLongValue>(input); }
 };
 
-struct DoubleValueFactory : public ValueFactory {
+struct DoubleValueFactory final : public ValueFactory {
     double input;
-    DoubleValueFactory(double in) : input(in) {}
+    DoubleValueFactory(double in) noexcept : input(in) {}
     Value *create(Stash & stash) const override { return & stash.create<BasicDoubleValue>(input); }
 };
 
-struct StringValueFactory : public ValueFactory {
+struct StringValueFactory final : public ValueFactory {
     Memory input;
-    StringValueFactory(Memory in) : input(in) {}
+    StringValueFactory(Memory in) noexcept : input(in) {}
     Value *create(Stash & stash) const override { return & stash.create<BasicStringValue>(input, stash); }
 };
 
-struct DataValueFactory : public ValueFactory {
+struct DataValueFactory final : public ValueFactory {
     Memory input;
-    DataValueFactory(Memory in) : input(in) {}
+    DataValueFactory(Memory in) noexcept : input(in) {}
     Value *create(Stash & stash) const override { return & stash.create<BasicDataValue>(input, stash); }
 };
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/cursor.h b/vespalib/src/vespa/vespalib/data/slime/cursor.h
index 34d7028a027..6f926de85b6 100644
--- a/vespalib/src/vespa/vespalib/data/slime/cursor.h
+++ b/vespalib/src/vespa/vespalib/data/slime/cursor.h
@@ -19,7 +19,7 @@ struct Cursor : public Inspector {
     virtual Cursor &addString(Memory str) = 0;
     virtual Cursor &addData(Memory data) = 0;
     virtual Cursor &addData(ExternalMemory::UP data) = 0;
-    virtual Cursor &addArray() = 0;
+    virtual Cursor &addArray(size_t reserved_size) = 0;
     virtual Cursor &addObject() = 0;
 
     virtual Cursor &setNix(Symbol sym) = 0;
@@ -29,7 +29,7 @@ struct Cursor : public Inspector {
     virtual Cursor &setString(Symbol sym, Memory str) = 0;
     virtual Cursor &setData(Symbol sym, Memory data) = 0;
     virtual Cursor &setData(Symbol sym, ExternalMemory::UP data) = 0;
-    virtual Cursor &setArray(Symbol sym) = 0;
+    virtual Cursor &setArray(Symbol sym, size_t reserved_size) = 0;
     virtual Cursor &setObject(Symbol sym) = 0;
 
     virtual Cursor &setNix(Memory name) = 0;
@@ -39,10 +39,20 @@ struct Cursor : public Inspector {
     virtual Cursor &setString(Memory name, Memory str) = 0;
     virtual Cursor &setData(Memory name, Memory data) = 0;
     virtual Cursor &setData(Memory name, ExternalMemory::UP data) = 0;
-    virtual Cursor &setArray(Memory name) = 0;
+    virtual Cursor &setArray(Memory name, size_t reserved_size) = 0;
     virtual Cursor &setObject(Memory name) = 0;
 
     virtual Symbol resolve(Memory symbol_name) = 0;
+
+    Cursor &addArray() {
+        return addArray(0);
+    }
+    Cursor &setArray(Memory name) {
+        return setArray(name, 0);
+    }
+    Cursor &setArray(Symbol sym) {
+        return setArray(sym, 0);
+    }
 };
 
 }
diff --git a/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.cpp b/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.cpp
index 95be18f57ae..f6573ad26c4 100644
--- a/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.cpp
@@ -9,7 +9,9 @@ namespace vespalib::slime {
 
 Value *
 ArrayValueFactory::create(Stash & stash) const {
-    return & stash.create<ArrayValue>(symbolTable, stash);
+    ArrayValue & arr = stash.create<ArrayValue>(symbolTable, stash);
+    arr.reserve(_reserve);
+    return &arr;
 }
 
 Value *
diff --git a/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.h b/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.h
index 4046a838ef3..c92b7ed1c68 100644
--- a/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.h
+++ b/vespalib/src/vespa/vespalib/data/slime/empty_value_factory.h
@@ -7,19 +7,20 @@
 
 namespace vespalib::slime {
 
-struct NixValueFactory : public ValueFactory {
+struct NixValueFactory final : public ValueFactory {
     Value *create(Stash &) const override { return NixValue::instance(); }
 };
 
-struct ArrayValueFactory : public ValueFactory {
+struct ArrayValueFactory final : public ValueFactory {
     SymbolTable &symbolTable;
-    ArrayValueFactory(SymbolTable &table) : symbolTable(table) {}
+    size_t _reserve;
+    ArrayValueFactory(SymbolTable &table, size_t reserve) noexcept : symbolTable(table), _reserve(reserve) {}
     Value *create(Stash & stash) const override;
 };
 
-struct ObjectValueFactory : public ValueFactory {
+struct ObjectValueFactory final : public ValueFactory {
     SymbolTable &symbolTable;
-    ObjectValueFactory(SymbolTable &table) : symbolTable(table) {}
+    ObjectValueFactory(SymbolTable &table) noexcept : symbolTable(table) {}
     Value *create(Stash & stash) const override;
 };
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/inserter.cpp b/vespalib/src/vespa/vespalib/data/slime/inserter.cpp
index 0042319d8a1..7e64800eefc 100644
--- a/vespalib/src/vespa/vespalib/data/slime/inserter.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/inserter.cpp
@@ -14,7 +14,7 @@ Cursor &SlimeInserter::insertDouble(double value) const { return slime.setDouble
 Cursor &SlimeInserter::insertString(Memory value) const { return slime.setString(value); }
 Cursor &SlimeInserter::insertData(Memory value)   const { return slime.setData(value); }
 Cursor &SlimeInserter::insertData(ExtMemUP value) const { return slime.setData(std::move(value)); }
-Cursor &SlimeInserter::insertArray()              const { return slime.setArray(); }
+Cursor &SlimeInserter::insertArray(size_t resv)   const { return slime.setArray(resv); }
 Cursor &SlimeInserter::insertObject()             const { return slime.setObject(); }
 
 Cursor &ArrayInserter::insertNix()                const { return cursor.addNix(); }
@@ -24,7 +24,7 @@ Cursor &ArrayInserter::insertDouble(double value) const { return cursor.addDoubl
 Cursor &ArrayInserter::insertString(Memory value) const { return cursor.addString(value); }
 Cursor &ArrayInserter::insertData(Memory value)   const { return cursor.addData(value); }
 Cursor &ArrayInserter::insertData(ExtMemUP value) const { return cursor.addData(std::move(value)); }
-Cursor &ArrayInserter::insertArray()              const { return cursor.addArray(); }
+Cursor &ArrayInserter::insertArray(size_t resv)   const { return cursor.addArray(resv); }
 Cursor &ArrayInserter::insertObject()             const { return cursor.addObject(); }
 
 Cursor &ObjectSymbolInserter::insertNix()                const { return cursor.setNix(symbol); }
@@ -34,7 +34,7 @@ Cursor &ObjectSymbolInserter::insertDouble(double value) const { return cursor.s
 Cursor &ObjectSymbolInserter::insertString(Memory value) const { return cursor.setString(symbol, value); }
 Cursor &ObjectSymbolInserter::insertData(Memory value)   const { return cursor.setData(symbol, value); }
 Cursor &ObjectSymbolInserter::insertData(ExtMemUP value) const { return cursor.setData(symbol, std::move(value)); }
-Cursor &ObjectSymbolInserter::insertArray()              const { return cursor.setArray(symbol); }
+Cursor &ObjectSymbolInserter::insertArray(size_t resv)   const { return cursor.setArray(symbol, resv); }
 Cursor &ObjectSymbolInserter::insertObject()             const { return cursor.setObject(symbol); }
 
 Cursor &ObjectInserter::insertNix()                const { return cursor.setNix(name); }
@@ -44,7 +44,7 @@ Cursor &ObjectInserter::insertDouble(double value) const { return cursor.setDoub
 Cursor &ObjectInserter::insertString(Memory value) const { return cursor.setString(name, value); }
 Cursor &ObjectInserter::insertData(Memory value)   const { return cursor.setData(name, value); }
 Cursor &ObjectInserter::insertData(ExtMemUP value) const { return cursor.setData(name, std::move(value)); }
-Cursor &ObjectInserter::insertArray()              const { return cursor.setArray(name); }
+Cursor &ObjectInserter::insertArray(size_t resv)   const { return cursor.setArray(name, resv); }
 Cursor &ObjectInserter::insertObject()             const { return cursor.setObject(name); }
 
 } // namespace vespalib::slime
diff --git a/vespalib/src/vespa/vespalib/data/slime/inserter.h b/vespalib/src/vespa/vespalib/data/slime/inserter.h
index 8206e67a79a..deddb5671c3 100644
--- a/vespalib/src/vespa/vespalib/data/slime/inserter.h
+++ b/vespalib/src/vespa/vespalib/data/slime/inserter.h
@@ -27,9 +27,13 @@ struct Inserter {
     virtual Cursor &insertString(Memory value) const = 0;
     virtual Cursor &insertData(Memory value) const = 0;
     virtual Cursor &insertData(ExternalMemory::UP value) const = 0;
-    virtual Cursor &insertArray() const = 0;
+    virtual Cursor &insertArray(size_t reserved) const = 0;
     virtual Cursor &insertObject() const = 0;
-    virtual ~Inserter() {}
+    virtual ~Inserter() = default;
+
+    Cursor &insertArray() const {
+        return insertArray(0);
+    }
 };
 
 //-----------------------------------------------------------------------------
@@ -45,7 +49,7 @@ struct SlimeInserter : Inserter {
     Cursor &insertString(Memory value) const override;
     Cursor &insertData(Memory value) const override;
     Cursor &insertData(ExternalMemory::UP value) const override;
-    Cursor &insertArray() const override;
+    Cursor &insertArray(size_t reserved) const override;
     Cursor &insertObject() const override;
 };
 
@@ -60,7 +64,7 @@ struct ArrayInserter : Inserter {
     Cursor &insertString(Memory value) const override;
     Cursor &insertData(Memory value) const override;
     Cursor &insertData(ExternalMemory::UP value) const override;
-    Cursor &insertArray() const override;
+    Cursor &insertArray(size_t reserved) const override;
     Cursor &insertObject() const override;
 };
 
@@ -76,7 +80,7 @@ struct ObjectSymbolInserter : Inserter {
     Cursor &insertString(Memory value) const override;
     Cursor &insertData(Memory value) const override;
     Cursor &insertData(ExternalMemory::UP value) const override;
-    Cursor &insertArray() const override;
+    Cursor &insertArray(size_t reserved) const override;
     Cursor &insertObject() const override;
 };
 
@@ -92,7 +96,7 @@ struct ObjectInserter : Inserter {
     Cursor &insertString(Memory value) const override;
     Cursor &insertData(Memory value) const override;
     Cursor &insertData(ExternalMemory::UP value) const override;
-    Cursor &insertArray() const override;
+    Cursor &insertArray(size_t reserved) const override;
     Cursor &insertObject() const override;
 };
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/named_symbol_inserter.h b/vespalib/src/vespa/vespalib/data/slime/named_symbol_inserter.h
index aac35b2e386..9752040d3e8 100644
--- a/vespalib/src/vespa/vespalib/data/slime/named_symbol_inserter.h
+++ b/vespalib/src/vespa/vespalib/data/slime/named_symbol_inserter.h
@@ -10,14 +10,14 @@ namespace vespalib::slime {
 /**
  * Class used to insert the name of a field into a symbol table.
  **/
-class NamedSymbolInserter : public SymbolInserter
+class NamedSymbolInserter final : public SymbolInserter
 {
 private:
     SymbolTable &_table;
     const Memory &_name;
 
 public:
-    NamedSymbolInserter(SymbolTable &table, const Memory &name)
+    NamedSymbolInserter(SymbolTable &table, const Memory &name) noexcept
         : _table(table), _name(name) {}
     Symbol insert() override {
         return _table.insert(_name);
diff --git a/vespalib/src/vespa/vespalib/data/slime/object_value.cpp b/vespalib/src/vespa/vespalib/data/slime/object_value.cpp
index f3436ac0978..25a5d762825 100644
--- a/vespalib/src/vespa/vespalib/data/slime/object_value.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/object_value.cpp
@@ -24,18 +24,16 @@ ObjectValue::setLeaf(Memory name, const ValueFactory &input) {
 
 void
 ObjectValue::traverse(ObjectSymbolTraverser &ot) const {
-    typedef SymbolValueMap::const_iterator ITR;
-    for (ITR pos = _fields.begin(); pos != _fields.end(); ++pos) {
-        ot.field(pos->first, *pos->second);
+    for (const auto & field : _fields) {
+        ot.field(field.first, *field.second);
     }
 }
 
 void
 ObjectValue::traverse(ObjectTraverser &ot) const {
-    typedef SymbolValueMap::const_iterator ITR;
-    for (ITR pos = _fields.begin(); pos != _fields.end(); ++pos) {
-        Memory symbol = _symbolTable.inspect(pos->first);
-        ot.field(symbol, *pos->second);
+    for (const auto & field : _fields) {
+        Memory symbol = _symbolTable.inspect(field.first);
+        ot.field(symbol, *field.second);
     }
 }
 
@@ -53,8 +51,8 @@ ObjectValue::operator[](Memory name) const {
 
 
 Cursor &
-ObjectValue::setArray(Symbol symbol) {
-    return setLeaf(symbol, ArrayValueFactory(_symbolTable));
+ObjectValue::setArray(Symbol symbol, size_t reserve) {
+    return setLeaf(symbol, ArrayValueFactory(_symbolTable, reserve));
 }
 
 Cursor &
@@ -63,8 +61,8 @@ ObjectValue::setObject(Symbol symbol) {
 }
 
 Cursor &
-ObjectValue::setArray(Memory name) {
-    return setLeaf(name, ArrayValueFactory(_symbolTable));
+ObjectValue::setArray(Memory name, size_t reserve) {
+    return setLeaf(name, ArrayValueFactory(_symbolTable, reserve));
 }
 
 Cursor &
diff --git a/vespalib/src/vespa/vespalib/data/slime/object_value.h b/vespalib/src/vespa/vespalib/data/slime/object_value.h
index 7f8a809a482..a26027f9e0d 100644
--- a/vespalib/src/vespa/vespalib/data/slime/object_value.h
+++ b/vespalib/src/vespa/vespalib/data/slime/object_value.h
@@ -17,13 +17,13 @@ namespace vespalib::slime {
  * Class representing a collection of unordered values that can be
  * looked up by symbol.
  **/
-class ObjectValue : public Value
+class ObjectValue final : public Value
 {
 private:
     struct hasher {
         size_t operator () (const Symbol & s) const { return s.getValue(); }
     };
-    typedef vector_map<Symbol, Value*> SymbolValueMap;
+    using SymbolValueMap = vector_map<Symbol, Value*>;
     SymbolTable    &_symbolTable;
     Stash          &_stash;
     SymbolValueMap  _fields;
@@ -72,10 +72,10 @@ public:
     Cursor &operator[](Symbol sym) const override;
     Cursor &operator[](Memory name) const override;
 
-    Cursor &setArray(Symbol sym) override;
+    Cursor &setArray(Symbol sym, size_t reserve) override;
     Cursor &setObject(Symbol sym) override;
 
-    Cursor &setArray(Memory name) override;
+    Cursor &setArray(Memory name, size_t reserve) override;
     Cursor &setObject(Memory name) override;
     Symbol resolve(Memory symbol_name) override;
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/resolved_symbol.h b/vespalib/src/vespa/vespalib/data/slime/resolved_symbol.h
index 2b8c39708c9..714230bdf94 100644
--- a/vespalib/src/vespa/vespalib/data/slime/resolved_symbol.h
+++ b/vespalib/src/vespa/vespalib/data/slime/resolved_symbol.h
@@ -13,14 +13,14 @@ namespace vespalib::slime {
  * appropriate symbol table. Thus, this class can satisfy both the
  * symbol lookup and inserter interfaces.
  **/
-class ResolvedSymbol : public SymbolLookup,
-                       public SymbolInserter
+class ResolvedSymbol final : public SymbolLookup,
+                             public SymbolInserter
 {
 private:
     Symbol _symbol;
 
 public:
-    ResolvedSymbol(const Symbol &symbol) : _symbol(symbol) {}
+    ResolvedSymbol(const Symbol &symbol) noexcept : _symbol(symbol) {}
     Symbol lookup() const override {
         return _symbol;
     }
diff --git a/vespalib/src/vespa/vespalib/data/slime/slime.h b/vespalib/src/vespa/vespalib/data/slime/slime.h
index 9959d8e7fc8..ee3222b2e8d 100644
--- a/vespalib/src/vespa/vespalib/data/slime/slime.h
+++ b/vespalib/src/vespa/vespalib/data/slime/slime.h
@@ -155,7 +155,10 @@ public:
         return _root.set(slime::ExternalDataValueFactory(std::move(data)));
     }
     Cursor &setArray() {
-        return _root.set(slime::ArrayValueFactory(*_names));
+        return setArray(0);
+    }
+    Cursor &setArray(size_t reserve) {
+        return _root.set(slime::ArrayValueFactory(*_names, reserve));
     }
     Cursor &setObject() {
         return _root.set(slime::ObjectValueFactory(*_names));
diff --git a/vespalib/src/vespa/vespalib/data/slime/value.cpp b/vespalib/src/vespa/vespalib/data/slime/value.cpp
index 300eeba47e5..f7c37d73652 100644
--- a/vespalib/src/vespa/vespalib/data/slime/value.cpp
+++ b/vespalib/src/vespa/vespalib/data/slime/value.cpp
@@ -130,16 +130,16 @@ Value::setData(Memory name, ExternalMemory::UP data) { return setLeaf(name, Exte
 
 // nop defaults for array/objects
 Cursor &
-Value::addArray() { return *NixValue::invalid(); }
+Value::addArray(size_t) { return *NixValue::invalid(); }
 Cursor &
 Value::addObject() { return *NixValue::invalid(); }
 
 Cursor &
-Value::setArray(Symbol) { return *NixValue::invalid(); }
+Value::setArray(Symbol, size_t) { return *NixValue::invalid(); }
 Cursor &
 Value::setObject(Symbol) { return *NixValue::invalid(); }
 Cursor &
-Value::setArray(Memory) { return *NixValue::invalid(); }
+Value::setArray(Memory, size_t) { return *NixValue::invalid(); }
 Cursor &
 Value::setObject(Memory) { return *NixValue::invalid(); }
 
diff --git a/vespalib/src/vespa/vespalib/data/slime/value.h b/vespalib/src/vespa/vespalib/data/slime/value.h
index 786f2bede91..930c182924e 100644
--- a/vespalib/src/vespa/vespalib/data/slime/value.h
+++ b/vespalib/src/vespa/vespalib/data/slime/value.h
@@ -21,7 +21,7 @@ struct ObjectTraverser;
 class Value : public Cursor
 {
 protected:
-    virtual ~Value() {}
+    virtual ~Value() = default;
 
     virtual Cursor &addLeaf(const ValueFactory &input);
     virtual Cursor &setLeaf(Symbol symbol, const ValueFactory &input);
@@ -57,7 +57,7 @@ public:
     Cursor &addString(Memory str) override;
     Cursor &addData(Memory data) override;
     Cursor &addData(ExternalMemory::UP data) override;
-    Cursor &addArray() override;
+    Cursor &addArray(size_t reserved_size) override;
     Cursor &addObject() override;
 
     Cursor &setNix(Symbol sym) override;
@@ -67,7 +67,7 @@ public:
     Cursor &setString(Symbol sym, Memory str) override;
     Cursor &setData(Symbol sym, Memory data) override;
     Cursor &setData(Symbol sym, ExternalMemory::UP data) override;
-    Cursor &setArray(Symbol sym) override;
+    Cursor &setArray(Symbol sym, size_t reserved_size) override;
     Cursor &setObject(Symbol sym) override;
 
     Cursor &setNix(Memory name) override;
@@ -77,7 +77,7 @@ public:
     Cursor &setString(Memory name, Memory str) override;
     Cursor &setData(Memory name, Memory str) override;
     Cursor &setData(Memory name, ExternalMemory::UP data) override;
-    Cursor &setArray(Memory name) override;
+    Cursor &setArray(Memory name, size_t reserved_size) override;
     Cursor &setObject(Memory name) override;
 
     Symbol resolve(Memory symbol_name) override;