change API to take ConstArrayRef instead of vectors

8 files changed, 71 insertions, 61 deletions

diff --git a/eval/src/tests/eval/simple_value/simple_value_test.cpp b/eval/src/tests/eval/simple_value/simple_value_test.cpp
index 4827fa3be3c..3d824913252 100644
--- a/eval/src/tests/eval/simple_value/simple_value_test.cpp
+++ b/eval/src/tests/eval/simple_value/simple_value_test.cpp
@@ -15,6 +15,9 @@ using namespace vespalib::eval::test;
 
 using vespalib::make_string_short::fmt;
 
+using PA = std::vector<vespalib::stringref *>;
+using CPA = std::vector<const vespalib::stringref *>;
+
 std::vector<Layout> layouts = {
     {},
     {x(3)},
@@ -105,14 +108,14 @@ TEST(SimpleValueTest, simple_value_can_be_built_and_inspected) {
     vespalib::stringref query = "b";
     vespalib::stringref label;
     size_t subspace;
-    view->lookup({&query});
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "aa");
     EXPECT_EQ(subspace, 2);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "bb");
     EXPECT_EQ(subspace, 3);
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 }
 
 TEST(SimpleValueTest, new_generic_join_works_for_simple_values) {
diff --git a/eval/src/tests/tensor/default_value_builder_factory/default_value_builder_factory_test.cpp b/eval/src/tests/tensor/default_value_builder_factory/default_value_builder_factory_test.cpp
index 28f8fcc7eb8..bd18f3a2341 100644
--- a/eval/src/tests/tensor/default_value_builder_factory/default_value_builder_factory_test.cpp
+++ b/eval/src/tests/tensor/default_value_builder_factory/default_value_builder_factory_test.cpp
@@ -18,6 +18,9 @@ Value::UP v_of(const TensorSpec &spec) {
     return value_from_spec(spec, DefaultValueBuilderFactory::get());
 }
 
+using PA = std::vector<vespalib::stringref *>;
+using CPA = std::vector<const vespalib::stringref *>;
+
 TEST(DefaultValueBuilderFactoryTest, all_built_value_types_are_correct) {
     auto dbl = v_of(TensorSpec("double").add({}, 3.0));
     auto trivial = v_of(TensorSpec("tensor(x[1])").add({{"x",0}}, 7.0));
@@ -40,19 +43,19 @@ TEST(DefaultValueBuilderFactoryTest, all_built_value_types_are_correct) {
     stringref y_look = "bar";
     stringref x_res = "xxx";
     auto view = sparse->index().create_view({1});
-    view->lookup({&y_look});
+    view->lookup(CPA{&y_look});
     size_t ss = 12345;
-    bool br = view->next_result({&x_res}, ss);
+    bool br = view->next_result(PA{&x_res}, ss);
     EXPECT_TRUE(br);
     EXPECT_EQ(ss, 0);
     EXPECT_EQ(x_res, "foo");
-    br = view->next_result({&x_res}, ss);
+    br = view->next_result(PA{&x_res}, ss);
     EXPECT_FALSE(br);
 
     ss = 12345;
     view = mixed->index().create_view({});
     view->lookup({});
-    br = view->next_result({&x_res}, ss);
+    br = view->next_result(PA{&x_res}, ss);
     EXPECT_TRUE(br);
     EXPECT_EQ(ss, 0);
     EXPECT_EQ(x_res, "quux");
diff --git a/eval/src/tests/tensor/packed_mappings/packed_mixed_test.cpp b/eval/src/tests/tensor/packed_mappings/packed_mixed_test.cpp
index bc1efdaba1d..ba2e01980d9 100644
--- a/eval/src/tests/tensor/packed_mappings/packed_mixed_test.cpp
+++ b/eval/src/tests/tensor/packed_mappings/packed_mixed_test.cpp
@@ -9,6 +9,9 @@
 using namespace vespalib::eval;
 using namespace vespalib::eval::test;
 
+using PA = std::vector<vespalib::stringref *>;
+using CPA = std::vector<const vespalib::stringref *>;
+
 std::vector<Layout> layouts = {
     {},
     {x(3)},
@@ -54,64 +57,65 @@ TEST(PackedMixedTest, packed_mixed_tensors_can_be_built_and_inspected) {
     vespalib::stringref query = "b";
     vespalib::stringref label;
     size_t subspace;
-    view->lookup({&query});
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "aa");
     EXPECT_EQ(subspace, 2);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "bb");
     EXPECT_EQ(subspace, 3);
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 
     query = "c";
-    view->lookup({&query});
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "aa");
     EXPECT_EQ(subspace, 4);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "bb");
     EXPECT_EQ(subspace, 5);
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
     
     query = "notpresent";
-    view->lookup({&query});
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 
     view = value->index().create_view({1});
     query = "aa";
-    view->lookup({&query});
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "a");
     EXPECT_EQ(subspace, 0);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "b");
     EXPECT_EQ(subspace, 2);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "c");
     EXPECT_EQ(subspace, 4);
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 
     query = "bb";
-    view->lookup({&query});
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "a");
     EXPECT_EQ(subspace, 1);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "b");
     EXPECT_EQ(subspace, 3);
-    EXPECT_TRUE(view->next_result({&label}, subspace));
+    EXPECT_TRUE(view->next_result(PA{&label}, subspace));
     EXPECT_EQ(label, "c");
     EXPECT_EQ(subspace, 5);
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 
     query = "notpresent";
-    view->lookup({&query});
-    EXPECT_FALSE(view->next_result({&label}, subspace));
+    view->lookup(CPA{&query});
+    EXPECT_FALSE(view->next_result(PA{&label}, subspace));
 
     view = value->index().create_view({0,1});
     vespalib::stringref query_x = "b";
     vespalib::stringref query_y = "bb";
-    view->lookup({&query_x, &query_y});
+    CPA addr = {&query_x, &query_y};
+    view->lookup(addr);
     EXPECT_TRUE(view->next_result({}, subspace));
     EXPECT_EQ(subspace, 3);
     EXPECT_FALSE(view->next_result({}, subspace));
diff --git a/eval/src/vespa/eval/eval/simple_value.cpp b/eval/src/vespa/eval/eval/simple_value.cpp
index 1ccf6f8cd25..889cbfe81e1 100644
--- a/eval/src/vespa/eval/eval/simple_value.cpp
+++ b/eval/src/vespa/eval/eval/simple_value.cpp
@@ -64,7 +64,7 @@ public:
         assert((_match_dims.size() + _extract_dims.size()) == _num_mapped_dims);
     }
 
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override {
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override {
         assert(addr.size() == _match_dims.size());
         for (size_t i = 0; i < _match_dims.size(); ++i) {
             _query[_match_dims[i]] = *addr[i];
@@ -76,7 +76,7 @@ public:
         }
     }
 
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override {
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override {
         assert(addr_out.size() == _extract_dims.size());
         while (_pos != _index.end()) {
             if (is_match()) {
diff --git a/eval/src/vespa/eval/eval/value.cpp b/eval/src/vespa/eval/eval/value.cpp
index 283950a6a67..7bf2d587904 100644
--- a/eval/src/vespa/eval/eval/value.cpp
+++ b/eval/src/vespa/eval/eval/value.cpp
@@ -10,8 +10,8 @@ namespace {
 
 struct TrivialView : Value::Index::View {
     bool first = false;
-    void lookup(const std::vector<const vespalib::stringref*> &) override { first = true; }
-    bool next_result(const std::vector<vespalib::stringref*> &, size_t &idx_out) override {
+    void lookup(ConstArrayRef<const vespalib::stringref*> ) override { first = true; }
+    bool next_result(ConstArrayRef<vespalib::stringref*> , size_t &idx_out) override {
         if (first) {
             idx_out = 0;
             first = false;
diff --git a/eval/src/vespa/eval/eval/value.h b/eval/src/vespa/eval/eval/value.h
index 4a9d9ae389a..ebcf960814f 100644
--- a/eval/src/vespa/eval/eval/value.h
+++ b/eval/src/vespa/eval/eval/value.h
@@ -37,13 +37,13 @@ struct Value {
             // partial address for the dimensions given to
             // create_view. Results from the lookup is extracted using
             // the next_result function.
-            virtual void lookup(const std::vector<const vespalib::stringref*> &addr) = 0;
+            virtual void lookup(ConstArrayRef<const vespalib::stringref*> addr) = 0;
 
             // Extract the next result (if any) from the previous
             // lookup into the given partial address and index. Only
             // the labels for the dimensions NOT specified in
             // create_view will be extracted here.
-            virtual bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) = 0;
+            virtual bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) = 0;
 
             virtual ~View() {}
         };
diff --git a/eval/src/vespa/eval/tensor/mixed/packed_mixed_tensor.cpp b/eval/src/vespa/eval/tensor/mixed/packed_mixed_tensor.cpp
index 43f0c27ffbd..660cad82e4f 100644
--- a/eval/src/vespa/eval/tensor/mixed/packed_mixed_tensor.cpp
+++ b/eval/src/vespa/eval/tensor/mixed/packed_mixed_tensor.cpp
@@ -30,13 +30,13 @@ public:
         _full_enums.resize(num_full_dims());
     }
 
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
     ~PackedMixedTensorIndexView() override = default;
 };
 
 void
-PackedMixedTensorIndexView::lookup(const std::vector<const vespalib::stringref*> &addr)
+PackedMixedTensorIndexView::lookup(ConstArrayRef<const vespalib::stringref*> addr)
 {
     _index = 0;
     assert(addr.size() == num_view_dims());
@@ -53,7 +53,7 @@ PackedMixedTensorIndexView::lookup(const std::vector<const vespalib::stringref*>
 }
 
 bool
-PackedMixedTensorIndexView::next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out)
+PackedMixedTensorIndexView::next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out)
 {
     assert(addr_out.size() == num_rest_dims());
     while (_index < _mappings.size()) {
@@ -109,13 +109,13 @@ public:
         _lookup_enums.reserve(num_full_dims());
     }
 
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
     ~PackedMixedTensorLookup() override = default;
 };
 
 void
-PackedMixedTensorLookup::lookup(const std::vector<const vespalib::stringref*> &addr)
+PackedMixedTensorLookup::lookup(ConstArrayRef<const vespalib::stringref*> addr)
 {
     assert(addr.size() == num_full_dims());
     _lookup_enums.clear();
@@ -132,7 +132,7 @@ PackedMixedTensorLookup::lookup(const std::vector<const vespalib::stringref*> &a
 }
 
 bool
-PackedMixedTensorLookup::next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out)
+PackedMixedTensorLookup::next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out)
 {
     assert(addr_out.size() == 0);
     if (_first_time) {
@@ -164,20 +164,20 @@ public:
         _full_address.resize(_mappings.num_mapped_dims());
     }
 
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
     ~PackedMixedTensorAllMappings() override = default;
 };
 
 void
-PackedMixedTensorAllMappings::lookup(const std::vector<const vespalib::stringref*> &addr)
+PackedMixedTensorAllMappings::lookup(ConstArrayRef<const vespalib::stringref*> addr)
 {
     _index = 0;
     assert(addr.size() == 0);
 }
 
 bool
-PackedMixedTensorAllMappings::next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out)
+PackedMixedTensorAllMappings::next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out)
 {
     assert(addr_out.size() == _mappings.num_mapped_dims());
     while (_index < _mappings.size()) {
diff --git a/eval/src/vespa/eval/tensor/sparse/sparse_tensor_index.cpp b/eval/src/vespa/eval/tensor/sparse/sparse_tensor_index.cpp
index 275acb51af3..b30d734f9ab 100644
--- a/eval/src/vespa/eval/tensor/sparse/sparse_tensor_index.cpp
+++ b/eval/src/vespa/eval/tensor/sparse/sparse_tensor_index.cpp
@@ -40,14 +40,14 @@ public:
                           const std::vector<size_t> &dims)
       : map(map_in), iter(map.end()), lookup_dims(dims), lookup_refs() {}
     ~SparseTensorValueView();
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
 };
 
 SparseTensorValueView::~SparseTensorValueView() = default;
 
 void
-SparseTensorValueView::lookup(const std::vector<const vespalib::stringref*> &addr)
+SparseTensorValueView::lookup(ConstArrayRef<const vespalib::stringref*> addr)
 {
     lookup_refs.clear();
     for (auto ptr : addr) {
@@ -58,7 +58,7 @@ SparseTensorValueView::lookup(const std::vector<const vespalib::stringref*> &add
 }
 
 bool
-SparseTensorValueView::next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out)
+SparseTensorValueView::next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out)
 {
     size_t total_dims = lookup_refs.size() + addr_out.size();
     while (iter != map.end()) {
@@ -108,14 +108,14 @@ private:
 public:
     SparseTensorValueLookup(const IndexMap & map_in) : map(map_in), iter(map.end()) {}
     ~SparseTensorValueLookup();
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
 };
 
 SparseTensorValueLookup::~SparseTensorValueLookup() = default;
 
 void
-SparseTensorValueLookup::lookup(const std::vector<const vespalib::stringref*> &addr)
+SparseTensorValueLookup::lookup(ConstArrayRef<const vespalib::stringref*> addr)
 {
     SparseTensorAddressBuilder builder;
     for (const auto & label : addr) {
@@ -126,7 +126,7 @@ SparseTensorValueLookup::lookup(const std::vector<const vespalib::stringref*> &a
 }
 
 bool
-SparseTensorValueLookup::next_result(const std::vector<vespalib::stringref*> &, size_t &idx_out)
+SparseTensorValueLookup::next_result(ConstArrayRef<vespalib::stringref*>, size_t &idx_out)
 {
     if (iter != map.end()) {
         idx_out = iter->second;
@@ -146,20 +146,20 @@ private:
 public:
     SparseTensorValueAllMappings(const IndexMap & map_in) : map(map_in), iter(map.end()) {}
     ~SparseTensorValueAllMappings();
-    void lookup(const std::vector<const vespalib::stringref*> &addr) override;
-    bool next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out) override;
+    void lookup(ConstArrayRef<const vespalib::stringref*> addr) override;
+    bool next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out) override;
 };
 
 SparseTensorValueAllMappings::~SparseTensorValueAllMappings() = default;
 
 void
-SparseTensorValueAllMappings::lookup(const std::vector<const vespalib::stringref*> &)
+SparseTensorValueAllMappings::lookup(ConstArrayRef<const vespalib::stringref*>)
 {
     iter = map.begin();
 }
 
 bool
-SparseTensorValueAllMappings::next_result(const std::vector<vespalib::stringref*> &addr_out, size_t &idx_out)
+SparseTensorValueAllMappings::next_result(ConstArrayRef<vespalib::stringref*> addr_out, size_t &idx_out)
 {
     if (iter != map.end()) {
         const auto & ref = iter->first;