peek into nbostream instead of copying strings

1 files changed, 41 insertions, 54 deletions

diff --git a/eval/src/vespa/eval/eval/value_codec.cpp b/eval/src/vespa/eval/eval/value_codec.cpp
index 5aad3f91b6a..90a3016d0ab 100644
--- a/eval/src/vespa/eval/eval/value_codec.cpp
+++ b/eval/src/vespa/eval/eval/value_codec.cpp
@@ -8,20 +8,56 @@ using namespace vespalib::eval::codec;
 
 namespace vespalib::eval {
 
+namespace {
+
 void encode_mapped_labels(nbostream &output, size_t num_mapped_dims, const std::vector<vespalib::stringref> &addr) {
     for (size_t i = 0; i < num_mapped_dims; ++i) {
         output.writeSmallString(addr[i]);
     }
 }
 
-void decode_mapped_labels(nbostream &input, size_t num_mapped_dims, std::vector<vespalib::string> &addr) {
+void decode_mapped_labels(nbostream &input, size_t num_mapped_dims, std::vector<vespalib::stringref> &addr) {
     for (size_t i = 0; i < num_mapped_dims; ++i) {
-        vespalib::string name;
-        input.readSmallString(name);
-        addr[i] = name;
+        size_t strSize = input.getInt1_4Bytes();
+        addr[i] = vespalib::stringref(input.peek(), strSize);
+        input.adjustReadPos(strSize);
     }
 }
 
+
+template<typename T>
+void decode_cells(nbostream &input, size_t num_cells, ArrayRef<T> dst)
+{
+    T value;
+    for (size_t i = 0; i < num_cells; ++i) {
+        input >> value;
+        dst[i] = value;
+    }
+}
+
+struct DecodeState {
+    const ValueType &type;
+    const size_t block_size;
+    const size_t num_blocks;
+    const size_t num_mapped_dims;
+};
+
+struct ContentDecoder {
+    template<typename T>
+    static std::unique_ptr<Value> invoke(nbostream &input, const DecodeState &state, const ValueBuilderFactory &factory) {
+        std::vector<vespalib::stringref> address(state.num_mapped_dims);
+        auto builder = factory.create_value_builder<T>(state.type, state.num_mapped_dims, state.block_size, state.num_blocks);
+        for (size_t i = 0; i < state.num_blocks; ++i) {
+            decode_mapped_labels(input, state.num_mapped_dims, address);
+            auto block_cells = builder->add_subspace(address);
+            decode_cells(input, state.block_size, block_cells);
+        }
+        return builder->build(std::move(builder));
+    }
+};
+
+} // namespace <unnamed>
+
 void new_encode(const Value &value, nbostream &output) {
     TypeMeta meta(value.type());
     Format format(meta);
@@ -54,61 +90,12 @@ void new_encode(const Value &value, nbostream &output) {
     }
 }
 
-template<typename T>
-void decode_cells(nbostream &input, size_t num_cells, ArrayRef<T> dst)
-{
-    T value;
-    for (size_t i = 0; i < num_cells; ++i) {
-        input >> value;
-        dst[i] = value;
-    }
-}
-
-struct DecodeState {
-    const ValueType &type;
-    const size_t block_size;
-    const size_t num_blocks;
-    const size_t num_mapped_dims;
-    std::vector<vespalib::string> address;
-    std::vector<vespalib::stringref> addr_refs;
-    DecodeState(const ValueType &type_in,
-                size_t block_size_in,
-                size_t num_blocks_in,
-                size_t num_mapped_dims_in)
-      : type(type_in),
-        block_size(block_size_in),
-        num_blocks(num_blocks_in),
-        num_mapped_dims(num_mapped_dims_in),
-        address(num_mapped_dims_in),
-        addr_refs(num_mapped_dims_in)
-    {}
-    void fix_refs() {
-        for (size_t j = 0; j < num_mapped_dims; ++j) {
-            addr_refs[j] = address[j];
-        }
-    }
-};
-
-struct ContentDecoder {
-    template<typename T>
-    static std::unique_ptr<Value> invoke(nbostream &input, DecodeState &state, const ValueBuilderFactory &factory) {
-        auto builder = factory.create_value_builder<T>(state.type, state.num_mapped_dims, state.block_size, state.num_blocks);
-        for (size_t i = 0; i < state.num_blocks; ++i) {
-            decode_mapped_labels(input, state.num_mapped_dims, state.address);
-            state.fix_refs();
-            auto block_cells = builder->add_subspace(state.addr_refs);
-            decode_cells(input, state.block_size, block_cells);
-        }
-        return builder->build(std::move(builder));
-    }
-};
-
 std::unique_ptr<Value> new_decode(nbostream &input, const ValueBuilderFactory &factory) {
     Format format(input.getInt1_4Bytes());
     ValueType type = decode_type(input, format);
     TypeMeta meta(type);
     const size_t num_blocks = maybe_decode_num_blocks(input, meta, format);
-    DecodeState state(type, meta.block_size, num_blocks, meta.mapped.size());
+    DecodeState state{type, meta.block_size, num_blocks, meta.mapped.size()};
     return typify_invoke<1,TypifyCellType,ContentDecoder>(meta.cell_type, input, state, factory);
 }