Prepare to support matched-elements-only for arrays and weighted sets of primitive types.

This renames StructFieldMapper to MatchingElementsFields with added support for basic fields.
Also some terminology is aligned.

18 files changed, 116 insertions, 112 deletions

diff --git a/searchsummary/src/tests/docsummary/attribute_combiner/attribute_combiner_test.cpp b/searchsummary/src/tests/docsummary/attribute_combiner/attribute_combiner_test.cpp
index 7a82187f355..ae8e5f88c28 100644
--- a/searchsummary/src/tests/docsummary/attribute_combiner/attribute_combiner_test.cpp
+++ b/searchsummary/src/tests/docsummary/attribute_combiner/attribute_combiner_test.cpp
@@ -9,7 +9,7 @@
 #include <vespa/searchlib/attribute/integerbase.h>
 #include <vespa/searchlib/attribute/stringbase.h>
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/searchlib/util/slime_output_raw_buf_adapter.h>
 #include <vespa/searchsummary/docsummary/docsumstate.h>
 #include <vespa/searchsummary/docsummary/docsum_field_writer_state.h>
@@ -171,7 +171,7 @@ public:
     void FillSummaryFeatures(GetDocsumsState *, IDocsumEnvironment *) override { }
     void FillRankFeatures(GetDocsumsState *, IDocsumEnvironment *) override { }
     void ParseLocation(GetDocsumsState *) override { }
-    std::unique_ptr<MatchingElements> fill_matching_elements(const search::StructFieldMapper &) override { return std::make_unique<MatchingElements>(_matching_elements); }
+    std::unique_ptr<MatchingElements> fill_matching_elements(const search::MatchingElementsFields &) override { return std::make_unique<MatchingElements>(_matching_elements); }
     ~DummyStateCallback() override { }
 };
 
@@ -196,7 +196,7 @@ struct AttributeCombinerTest : public ::testing::Test
     std::unique_ptr<IDocsumFieldWriter> writer;
     DummyStateCallback                  stateCallback;
     GetDocsumsState                     state;
-    std::shared_ptr<search::StructFieldMapper> _struct_field_mapper;
+    std::shared_ptr<search::MatchingElementsFields> _matching_elems_fields;
 
     AttributeCombinerTest();
     ~AttributeCombinerTest();
@@ -209,7 +209,7 @@ AttributeCombinerTest::AttributeCombinerTest()
       writer(),
       stateCallback(),
       state(stateCallback),
-      _struct_field_mapper()
+      _matching_elems_fields()
 {
     state._attrCtx = attrs.mgr.createContext();
 }
@@ -220,9 +220,9 @@ void
 AttributeCombinerTest::set_field(const vespalib::string &field_name, bool filter_elements)
 {
     if (filter_elements) {
-        _struct_field_mapper = std::make_shared<search::StructFieldMapper>();
+        _matching_elems_fields = std::make_shared<search::MatchingElementsFields>();
     }
-    writer = AttributeCombinerDFW::create(field_name, *state._attrCtx, filter_elements, _struct_field_mapper);
+    writer = AttributeCombinerDFW::create(field_name, *state._attrCtx, filter_elements, _matching_elems_fields);
     EXPECT_TRUE(writer->setFieldWriterStateIndex(0));
     state._fieldWriterStates.resize(1);
 }
@@ -308,43 +308,43 @@ TEST_F(AttributeCombinerTest, require_that_attribute_combiner_dfw_generates_corr
     assertWritten("null", 5);
 }
 
-TEST_F(AttributeCombinerTest, require_that_struct_field_mapper_is_setup_for_filtered_array_of_struct)
+TEST_F(AttributeCombinerTest, require_that_matching_elems_fields_is_setup_for_filtered_array_of_struct)
 {
     set_field("array", true);
-    EXPECT_TRUE(_struct_field_mapper);
-    EXPECT_TRUE(_struct_field_mapper->is_struct_field("array"));
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("map"));
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("smap"));
-    EXPECT_EQ("", _struct_field_mapper->get_struct_field("array.foo"));
-    EXPECT_EQ("array", _struct_field_mapper->get_struct_field("array.name"));
-    EXPECT_EQ("array", _struct_field_mapper->get_struct_field("array.val"));
-    EXPECT_EQ("array", _struct_field_mapper->get_struct_field("array.fval"));
+    EXPECT_TRUE(_matching_elems_fields);
+    EXPECT_TRUE(_matching_elems_fields->has_field("array"));
+    EXPECT_FALSE(_matching_elems_fields->has_field("map"));
+    EXPECT_FALSE(_matching_elems_fields->has_field("smap"));
+    EXPECT_EQ("", _matching_elems_fields->get_enclosing_field("array.foo"));
+    EXPECT_EQ("array", _matching_elems_fields->get_enclosing_field("array.name"));
+    EXPECT_EQ("array", _matching_elems_fields->get_enclosing_field("array.val"));
+    EXPECT_EQ("array", _matching_elems_fields->get_enclosing_field("array.fval"));
 }
 
-TEST_F(AttributeCombinerTest, require_that_struct_field_mapper_is_setup_for_filtered_map_of_struct)
+TEST_F(AttributeCombinerTest, require_that_matching_elems_fields_is_setup_for_filtered_map_of_struct)
 {
     set_field("smap", true);
-    EXPECT_TRUE(_struct_field_mapper);
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("array"));
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("map"));
-    EXPECT_TRUE(_struct_field_mapper->is_struct_field("smap"));
-    EXPECT_EQ("", _struct_field_mapper->get_struct_field("smap.foo"));
-    EXPECT_EQ("smap", _struct_field_mapper->get_struct_field("smap.key"));
-    EXPECT_EQ("smap", _struct_field_mapper->get_struct_field("smap.value.name"));
-    EXPECT_EQ("smap", _struct_field_mapper->get_struct_field("smap.value.val"));
-    EXPECT_EQ("smap", _struct_field_mapper->get_struct_field("smap.value.fval"));
+    EXPECT_TRUE(_matching_elems_fields);
+    EXPECT_FALSE(_matching_elems_fields->has_field("array"));
+    EXPECT_FALSE(_matching_elems_fields->has_field("map"));
+    EXPECT_TRUE(_matching_elems_fields->has_field("smap"));
+    EXPECT_EQ("", _matching_elems_fields->get_enclosing_field("smap.foo"));
+    EXPECT_EQ("smap", _matching_elems_fields->get_enclosing_field("smap.key"));
+    EXPECT_EQ("smap", _matching_elems_fields->get_enclosing_field("smap.value.name"));
+    EXPECT_EQ("smap", _matching_elems_fields->get_enclosing_field("smap.value.val"));
+    EXPECT_EQ("smap", _matching_elems_fields->get_enclosing_field("smap.value.fval"));
 }
 
-TEST_F(AttributeCombinerTest, require_that_struct_field_mapper_is_setup_for_filtered_map_of_string)
+TEST_F(AttributeCombinerTest, require_that_matching_elems_fields_is_setup_for_filtered_map_of_string)
 {
     set_field("map", true);
-    EXPECT_TRUE(_struct_field_mapper);
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("array"));
-    EXPECT_TRUE(_struct_field_mapper->is_struct_field("map"));
-    EXPECT_FALSE(_struct_field_mapper->is_struct_field("smap"));
-    EXPECT_EQ("", _struct_field_mapper->get_struct_field("map.foo"));
-    EXPECT_EQ("map", _struct_field_mapper->get_struct_field("map.key"));
-    EXPECT_EQ("map", _struct_field_mapper->get_struct_field("map.value"));
+    EXPECT_TRUE(_matching_elems_fields);
+    EXPECT_FALSE(_matching_elems_fields->has_field("array"));
+    EXPECT_TRUE(_matching_elems_fields->has_field("map"));
+    EXPECT_FALSE(_matching_elems_fields->has_field("smap"));
+    EXPECT_EQ("", _matching_elems_fields->get_enclosing_field("map.foo"));
+    EXPECT_EQ("map", _matching_elems_fields->get_enclosing_field("map.key"));
+    EXPECT_EQ("map", _matching_elems_fields->get_enclosing_field("map.value"));
 }
 
 }
diff --git a/searchsummary/src/tests/docsummary/matched_elements_filter/matched_elements_filter_test.cpp b/searchsummary/src/tests/docsummary/matched_elements_filter/matched_elements_filter_test.cpp
index dff3acc5b89..ed91d4a88eb 100644
--- a/searchsummary/src/tests/docsummary/matched_elements_filter/matched_elements_filter_test.cpp
+++ b/searchsummary/src/tests/docsummary/matched_elements_filter/matched_elements_filter_test.cpp
@@ -7,7 +7,7 @@
 #include <vespa/searchlib/attribute/attributefactory.h>
 #include <vespa/searchlib/attribute/attributevector.h>
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/searchlib/util/slime_output_raw_buf_adapter.h>
 #include <vespa/searchsummary/docsummary/docsumstate.h>
 #include <vespa/searchsummary/docsummary/idocsumenvironment.h>
@@ -26,7 +26,7 @@ LOG_SETUP("matched_elements_filter_test");
 using search::AttributeFactory;
 using search::AttributeVector;
 using search::MatchingElements;
-using search::StructFieldMapper;
+using search::MatchingElementsFields;
 using search::attribute::BasicType;
 using search::attribute::CollectionType;
 using search::attribute::Config;
@@ -178,7 +178,7 @@ public:
     void FillSummaryFeatures(GetDocsumsState*, IDocsumEnvironment*) override {}
     void FillRankFeatures(GetDocsumsState*, IDocsumEnvironment*) override {}
     void ParseLocation(GetDocsumsState*) override {}
-    std::unique_ptr<MatchingElements> fill_matching_elements(const StructFieldMapper&) override {
+    std::unique_ptr<MatchingElements> fill_matching_elements(const MatchingElementsFields&) override {
         auto result = std::make_unique<MatchingElements>();
         result->add_matching_elements(doc_id, _field_name, _matching_elements);
         return result;
@@ -189,7 +189,7 @@ class MatchedElementsFilterTest : public ::testing::Test {
 private:
     DocsumStore _doc_store;
     AttributeContext _attr_ctx;
-    std::shared_ptr<StructFieldMapper> _mapper;
+    std::shared_ptr<MatchingElementsFields> _fields;
 
     Slime run_filter_field_writer(const std::string& input_field_name, const ElementVector& matching_elements) {
         auto writer = make_field_writer(input_field_name);
@@ -209,21 +209,21 @@ public:
     MatchedElementsFilterTest()
         : _doc_store(),
           _attr_ctx(),
-          _mapper(std::make_shared<StructFieldMapper>())
+          _fields(std::make_shared<MatchingElementsFields>())
     {
     }
     ~MatchedElementsFilterTest() {}
     std::unique_ptr<IDocsumFieldWriter> make_field_writer(const std::string& input_field_name) {
         int input_field_enum = _doc_store.get_config().GetFieldNameEnum().Lookup(input_field_name.c_str());
         return MatchedElementsFilterDFW::create(input_field_name, input_field_enum,
-                                                _attr_ctx, _mapper);
+                                                _attr_ctx, _fields);
     }
     void expect_filtered(const std::string& input_field_name, const ElementVector& matching_elements, const std::string& exp_slime_as_json) {
         Slime act = run_filter_field_writer(input_field_name, matching_elements);
         SlimeValue exp(exp_slime_as_json);
         EXPECT_EQ(exp.slime, act);
     }
-    const StructFieldMapper& mapper() const { return *_mapper; }
+    const MatchingElementsFields& fields() const { return *_fields; }
 };
 
 TEST_F(MatchedElementsFilterTest, filters_elements_in_array_field_value)
@@ -249,12 +249,12 @@ TEST_F(MatchedElementsFilterTest, filters_elements_in_array_field_value_when_inp
     expect_filtered("array_in_doc", {0, 1, 100}, "[]");
 }
 
-TEST_F(MatchedElementsFilterTest, struct_field_mapper_is_setup_for_array_field_value)
+TEST_F(MatchedElementsFilterTest, matching_elements_fields_is_setup_for_array_field_value)
 {
     auto writer = make_field_writer("array");
-    EXPECT_TRUE(mapper().is_struct_field("array"));
-    EXPECT_EQ("", mapper().get_struct_field("array.name"));
-    EXPECT_EQ("array", mapper().get_struct_field("array.weight"));
+    EXPECT_TRUE(fields().has_field("array"));
+    EXPECT_EQ("", fields().get_enclosing_field("array.name"));
+    EXPECT_EQ("array", fields().get_enclosing_field("array.weight"));
 }
 
 TEST_F(MatchedElementsFilterTest, filters_elements_in_map_field_value)
@@ -280,21 +280,21 @@ TEST_F(MatchedElementsFilterTest, filters_elements_in_map_field_value_when_input
     expect_filtered("map_in_doc", {0, 1, 100}, "[]");
 }
 
-TEST_F(MatchedElementsFilterTest, struct_field_mapper_is_setup_for_map_field_value)
+TEST_F(MatchedElementsFilterTest, matching_elements_fields_is_setup_for_map_field_value)
 {
     {
         auto writer = make_field_writer("map");
-        EXPECT_TRUE(mapper().is_struct_field("map"));
-        EXPECT_EQ("", mapper().get_struct_field("map.key"));
-        EXPECT_EQ("map", mapper().get_struct_field("map.value.name"));
-        EXPECT_EQ("", mapper().get_struct_field("map.value.weight"));
+        EXPECT_TRUE(fields().has_field("map"));
+        EXPECT_EQ("", fields().get_enclosing_field("map.key"));
+        EXPECT_EQ("map", fields().get_enclosing_field("map.value.name"));
+        EXPECT_EQ("", fields().get_enclosing_field("map.value.weight"));
     }
     {
         auto writer = make_field_writer("map2");
-        EXPECT_TRUE(mapper().is_struct_field("map2"));
-        EXPECT_EQ("map2", mapper().get_struct_field("map2.key"));
-        EXPECT_EQ("", mapper().get_struct_field("map2.value.name"));
-        EXPECT_EQ("", mapper().get_struct_field("map2.value.weight"));
+        EXPECT_TRUE(fields().has_field("map2"));
+        EXPECT_EQ("map2", fields().get_enclosing_field("map2.key"));
+        EXPECT_EQ("", fields().get_enclosing_field("map2.value.name"));
+        EXPECT_EQ("", fields().get_enclosing_field("map2.value.weight"));
     }
 }
 
diff --git a/searchsummary/src/tests/docsummary/positionsdfw_test.cpp b/searchsummary/src/tests/docsummary/positionsdfw_test.cpp
index 4cad98a8e01..f54b4c19dc3 100644
--- a/searchsummary/src/tests/docsummary/positionsdfw_test.cpp
+++ b/searchsummary/src/tests/docsummary/positionsdfw_test.cpp
@@ -110,7 +110,7 @@ struct MyGetDocsumsStateCallback : GetDocsumsStateCallback {
     virtual void FillSummaryFeatures(GetDocsumsState *, IDocsumEnvironment *) override {}
     virtual void FillRankFeatures(GetDocsumsState *, IDocsumEnvironment *) override {}
     virtual void ParseLocation(GetDocsumsState *) override {}
-    std::unique_ptr<MatchingElements> fill_matching_elements(const StructFieldMapper &) override { abort(); }
+    std::unique_ptr<MatchingElements> fill_matching_elements(const MatchingElementsFields &) override { abort(); }
 };
 
 template <typename AttrType>
diff --git a/searchsummary/src/tests/docsummary/slime_summary/slime_summary_test.cpp b/searchsummary/src/tests/docsummary/slime_summary/slime_summary_test.cpp
index 5b74666cbec..6fceef37f09 100644
--- a/searchsummary/src/tests/docsummary/slime_summary/slime_summary_test.cpp
+++ b/searchsummary/src/tests/docsummary/slime_summary/slime_summary_test.cpp
@@ -78,7 +78,7 @@ struct DocsumFixture : IDocsumStore, GetDocsumsStateCallback {
     void FillSummaryFeatures(GetDocsumsState *, IDocsumEnvironment *) override { }
     void FillRankFeatures(GetDocsumsState *, IDocsumEnvironment *) override { }
     void ParseLocation(GetDocsumsState *) override { }
-    std::unique_ptr<MatchingElements> fill_matching_elements(const search::StructFieldMapper &) override { abort(); }
+    std::unique_ptr<MatchingElements> fill_matching_elements(const search::MatchingElementsFields &) override { abort(); }
 };
 
 
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
index 4e3cbaa512d..7a656eb0422 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
@@ -7,7 +7,7 @@
 #include <vespa/searchcommon/attribute/iattributecontext.h>
 #include <vespa/searchcommon/attribute/iattributevector.h>
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/data/slime/cursor.h>
 #include <cassert>
 
@@ -105,14 +105,14 @@ ArrayAttributeFieldWriterState::insertField(uint32_t docId, vespalib::slime::Ins
 ArrayAttributeCombinerDFW::ArrayAttributeCombinerDFW(const vespalib::string &fieldName,
                                                      const StructFieldsResolver& fields_resolver,
                                                      bool filter_elements,
-                                                     std::shared_ptr<StructFieldMapper> struct_field_mapper)
-    : AttributeCombinerDFW(fieldName, filter_elements, std::move(struct_field_mapper)),
+                                                     std::shared_ptr<MatchingElementsFields> matching_elems_fields)
+    : AttributeCombinerDFW(fieldName, filter_elements, std::move(matching_elems_fields)),
       _fields(fields_resolver.get_array_fields()),
       _attributeNames(fields_resolver.get_array_attributes()),
       _is_map_of_scalar(fields_resolver.is_map_of_scalar())
 {
-    if (filter_elements && _struct_field_mapper && !_struct_field_mapper->is_struct_field(fieldName)) {
-        fields_resolver.apply_to(*_struct_field_mapper);
+    if (filter_elements && _matching_elems_fields && !_matching_elems_fields->has_field(fieldName)) {
+        fields_resolver.apply_to(*_matching_elems_fields);
     }
 }
 
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
index 2fda1f69572..742128a229d 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
@@ -27,7 +27,7 @@ public:
     ArrayAttributeCombinerDFW(const vespalib::string &fieldName,
                               const StructFieldsResolver& fields_resolver,
                               bool filter_elements,
-                              std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                              std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     ~ArrayAttributeCombinerDFW() override;
 };
 
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
index 8eb77c0ed9c..4ad42133f14 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
@@ -6,7 +6,7 @@
 #include "docsumstate.h"
 #include "struct_fields_resolver.h"
 #include "struct_map_attribute_combiner_dfw.h"
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <algorithm>
 
 #include <vespa/log/log.h>
@@ -16,12 +16,13 @@ using search::attribute::IAttributeContext;
 
 namespace search::docsummary {
 
-AttributeCombinerDFW::AttributeCombinerDFW(const vespalib::string &fieldName, bool filter_elements, std::shared_ptr<StructFieldMapper> struct_field_mapper)
+AttributeCombinerDFW::AttributeCombinerDFW(const vespalib::string &fieldName, bool filter_elements,
+                                           std::shared_ptr<MatchingElementsFields> matching_elems_fields)
     : ISimpleDFW(),
       _stateIndex(0),
       _filter_elements(filter_elements),
       _fieldName(fieldName),
-      _struct_field_mapper(std::move(struct_field_mapper))
+      _matching_elems_fields(std::move(matching_elems_fields))
 {
 }
 
@@ -41,15 +42,16 @@ AttributeCombinerDFW::setFieldWriterStateIndex(uint32_t fieldWriterStateIndex)
 }
 
 std::unique_ptr<IDocsumFieldWriter>
-AttributeCombinerDFW::create(const vespalib::string &fieldName, IAttributeContext &attrCtx, bool filter_elements, std::shared_ptr<StructFieldMapper> struct_field_mapper)
+AttributeCombinerDFW::create(const vespalib::string &fieldName, IAttributeContext &attrCtx, bool filter_elements,
+                             std::shared_ptr<MatchingElementsFields> matching_elems_fields)
 {
     StructFieldsResolver structFields(fieldName, attrCtx, true);
     if (structFields.has_error()) {
         return std::unique_ptr<IDocsumFieldWriter>();
     } else if (structFields.is_map_of_struct()) {
-        return std::make_unique<StructMapAttributeCombinerDFW>(fieldName, structFields, filter_elements, std::move(struct_field_mapper));
+        return std::make_unique<StructMapAttributeCombinerDFW>(fieldName, structFields, filter_elements, std::move(matching_elems_fields));
     }
-    return std::make_unique<ArrayAttributeCombinerDFW>(fieldName, structFields, filter_elements, std::move(struct_field_mapper));
+    return std::make_unique<ArrayAttributeCombinerDFW>(fieldName, structFields, filter_elements, std::move(matching_elems_fields));
 }
 
 void
@@ -59,7 +61,7 @@ AttributeCombinerDFW::insertField(uint32_t docid, GetDocsumsState *state, ResTyp
     if (!fieldWriterState) {
         const MatchingElements *matching_elements = nullptr;
         if (_filter_elements) {
-            matching_elements = &state->get_matching_elements(*_struct_field_mapper);
+            matching_elements = &state->get_matching_elements(*_matching_elems_fields);
         }
         fieldWriterState = allocFieldWriterState(*state->_attrCtx, matching_elements);
     }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
index a8ab5f2f8f5..bb635d4d280 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
@@ -6,7 +6,7 @@
 
 namespace search {
 class MatchingElements;
-class StructFieldMapper;
+class MatchingElementsFields;
 }
 namespace search::attribute { class IAttributeContext; }
 
@@ -25,15 +25,17 @@ protected:
     uint32_t _stateIndex;
     const bool _filter_elements;
     vespalib::string _fieldName;
-    std::shared_ptr<StructFieldMapper> _struct_field_mapper;
-    AttributeCombinerDFW(const vespalib::string &fieldName, bool filter_elements, std::shared_ptr<StructFieldMapper> struct_field_mapper);
+    std::shared_ptr<MatchingElementsFields> _matching_elems_fields;
+    AttributeCombinerDFW(const vespalib::string &fieldName, bool filter_elements,
+                         std::shared_ptr<MatchingElementsFields> matching_elems_fields);
 protected:
     virtual std::unique_ptr<DocsumFieldWriterState> allocFieldWriterState(search::attribute::IAttributeContext &context, const MatchingElements* matching_elements) = 0;
 public:
     ~AttributeCombinerDFW() override;
     bool IsGenerated() const override;
     bool setFieldWriterStateIndex(uint32_t fieldWriterStateIndex) override;
-    static std::unique_ptr<IDocsumFieldWriter> create(const vespalib::string &fieldName, search::attribute::IAttributeContext &attrCtx, bool filter_elements, std::shared_ptr<StructFieldMapper> struct_field_mapper);
+    static std::unique_ptr<IDocsumFieldWriter> create(const vespalib::string &fieldName, search::attribute::IAttributeContext &attrCtx,
+                                                      bool filter_elements, std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     void insertField(uint32_t docid, GetDocsumsState *state, ResType type, vespalib::slime::Inserter &target) override;
 };
 
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.cpp b/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.cpp
index 9235ce2b181..2c3366cb94d 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.cpp
@@ -10,7 +10,7 @@
 #include "positionsdfw.h"
 #include "rankfeaturesdfw.h"
 #include "textextractordfw.h"
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/util/stringfmt.h>
 #include <vespa/vespalib/util/exceptions.h>
 
@@ -25,7 +25,7 @@ DynamicDocsumConfig::getResultConfig() const {
 }
 
 IDocsumFieldWriter::UP
-DynamicDocsumConfig::createFieldWriter(const string & fieldName, const string & overrideName, const string & argument, bool & rc, std::shared_ptr<StructFieldMapper> struct_field_mapper)
+DynamicDocsumConfig::createFieldWriter(const string & fieldName, const string & overrideName, const string & argument, bool & rc, std::shared_ptr<MatchingElementsFields> matching_elems_fields)
 {
     const ResultConfig & resultConfig = getResultConfig();
     rc = false;
@@ -97,14 +97,14 @@ DynamicDocsumConfig::createFieldWriter(const string & fieldName, const string &
     } else if (overrideName == "attributecombiner") {
         if (getEnvironment() && getEnvironment()->getAttributeManager()) {
             auto attr_ctx = getEnvironment()->getAttributeManager()->createContext();
-            fieldWriter = AttributeCombinerDFW::create(fieldName, *attr_ctx, false, std::shared_ptr<StructFieldMapper>());
+            fieldWriter = AttributeCombinerDFW::create(fieldName, *attr_ctx, false, std::shared_ptr<MatchingElementsFields>());
             rc = static_cast<bool>(fieldWriter);
         }
     } else if (overrideName == "matchedattributeelementsfilter") {
         string source_field = argument.empty() ? fieldName : argument;
         if (getEnvironment() && getEnvironment()->getAttributeManager()) {
             auto attr_ctx = getEnvironment()->getAttributeManager()->createContext();
-            fieldWriter = AttributeCombinerDFW::create(source_field, *attr_ctx, true, struct_field_mapper);
+            fieldWriter = AttributeCombinerDFW::create(source_field, *attr_ctx, true, matching_elems_fields);
             rc = static_cast<bool>(fieldWriter);
         }
     } else if (overrideName == "matchedelementsfilter") {
@@ -112,7 +112,7 @@ DynamicDocsumConfig::createFieldWriter(const string & fieldName, const string &
         if (getEnvironment() && getEnvironment()->getAttributeManager()) {
             auto attr_ctx = getEnvironment()->getAttributeManager()->createContext();
             fieldWriter = MatchedElementsFilterDFW::create(source_field, resultConfig.GetFieldNameEnum().Lookup(source_field.c_str()),
-                                                           *attr_ctx, struct_field_mapper);
+                                                           *attr_ctx, matching_elems_fields);
             rc = static_cast<bool>(fieldWriter);
         }
     } else {
@@ -125,14 +125,14 @@ void
 DynamicDocsumConfig::configure(const vespa::config::search::SummarymapConfig &cfg)
 {
     std::vector<string> strCfg;
-    auto struct_field_mapper = std::make_shared<StructFieldMapper>();
+    auto matching_elems_fields = std::make_shared<MatchingElementsFields>();
     if ((cfg.defaultoutputclass != -1) && !_writer->SetDefaultOutputClass(cfg.defaultoutputclass)) {
         throw IllegalArgumentException(make_string("could not set default output class to %d", cfg.defaultoutputclass));
     }
     for (size_t i = 0; i < cfg.override.size(); ++i) {
         const vespa::config::search::SummarymapConfig::Override & o = cfg.override[i];
         bool rc(false);
-        IDocsumFieldWriter::UP fieldWriter = createFieldWriter(o.field, o.command, o.arguments, rc, struct_field_mapper);
+        IDocsumFieldWriter::UP fieldWriter = createFieldWriter(o.field, o.command, o.arguments, rc, matching_elems_fields);
         if (rc && fieldWriter.get() != NULL) {
             rc = _writer->Override(o.field.c_str(), fieldWriter.release()); // OBJECT HAND-OVER
         }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.h b/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.h
index 34ca49824c5..f6f1939cc62 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumconfig.h
@@ -4,7 +4,7 @@
 
 #include <vespa/config-summarymap.h>
 
-namespace search { class StructFieldMapper; }
+namespace search { class MatchingElementsFields; }
 namespace search::docsummary {
 
 class IDocsumEnvironment;
@@ -29,7 +29,7 @@ protected:
 
     virtual std::unique_ptr<IDocsumFieldWriter>
     createFieldWriter(const string & fieldName, const string & overrideName,
-                      const string & argument, bool & rc, std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                      const string & argument, bool & rc, std::shared_ptr<MatchingElementsFields> matching_elems_fields);
 private:
     IDocsumEnvironment  * _env;
     DynamicDocsumWriter * _writer;
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
index 3270e4b4c98..ebbf97e9f55 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
@@ -50,10 +50,10 @@ GetDocsumsState::~GetDocsumsState()
 }
 
 const MatchingElements &
-GetDocsumsState::get_matching_elements(const StructFieldMapper &struct_field_mapper)
+GetDocsumsState::get_matching_elements(const MatchingElementsFields &matching_elems_fields)
 {
     if (!_matching_elements) {
-        _matching_elements = _callback.fill_matching_elements(struct_field_mapper);
+        _matching_elements = _callback.fill_matching_elements(matching_elems_fields);
     }
     return *_matching_elements;
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
index 350e2410c9d..57cae341682 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
@@ -15,7 +15,7 @@ namespace juniper {
 
 namespace search {
 class MatchingElements;
-class StructFieldMapper;
+class MatchingElementsFields;
 }
 namespace search::common { class Location; }
 namespace search::attribute {
@@ -35,7 +35,7 @@ public:
     virtual void FillSummaryFeatures(GetDocsumsState * state, IDocsumEnvironment * env) = 0;
     virtual void FillRankFeatures(GetDocsumsState * state, IDocsumEnvironment * env) = 0;
     virtual void ParseLocation(GetDocsumsState * state) = 0;
-    virtual std::unique_ptr<MatchingElements> fill_matching_elements(const StructFieldMapper &struct_field_mapper) = 0;
+    virtual std::unique_ptr<MatchingElements> fill_matching_elements(const MatchingElementsFields &matching_elems_fields) = 0;
     virtual ~GetDocsumsStateCallback(void) { }
     GetDocsumsStateCallback(const GetDocsumsStateCallback &) = delete;
     GetDocsumsStateCallback & operator = (const GetDocsumsStateCallback &) = delete;
@@ -96,7 +96,7 @@ public:
     GetDocsumsState& operator=(const GetDocsumsState &) = delete;
     GetDocsumsState(GetDocsumsStateCallback &callback);
     ~GetDocsumsState();
-    const MatchingElements &get_matching_elements(const StructFieldMapper &struct_field_mapper);
+    const MatchingElements &get_matching_elements(const MatchingElementsFields &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 443634b3e3f..6991d3acb29 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.cpp
@@ -8,7 +8,7 @@
 #include <vespa/document/fieldvalue/literalfieldvalue.h>
 #include <vespa/searchcommon/attribute/iattributecontext.h>
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/data/slime/binary_format.h>
 #include <vespa/vespalib/data/slime/slime.h>
 #include <vespa/vespalib/data/smart_buffer.h>
@@ -29,35 +29,35 @@ namespace search::docsummary {
 const std::vector<uint32_t>&
 MatchedElementsFilterDFW::get_matching_elements(uint32_t docid, GetDocsumsState& state) const
 {
-    return state.get_matching_elements(*_struct_field_mapper).get_matching_elements(docid, _input_field_name);
+    return state.get_matching_elements(*_matching_elems_fields).get_matching_elements(docid, _input_field_name);
 }
 
 MatchedElementsFilterDFW::MatchedElementsFilterDFW(const std::string& input_field_name, uint32_t input_field_enum,
-                                                   std::shared_ptr<StructFieldMapper> struct_field_mapper)
+                                                   std::shared_ptr<MatchingElementsFields> matching_elems_fields)
     : _input_field_name(input_field_name),
       _input_field_enum(input_field_enum),
-      _struct_field_mapper(std::move(struct_field_mapper))
+      _matching_elems_fields(std::move(matching_elems_fields))
 {
 }
 
 std::unique_ptr<IDocsumFieldWriter>
 MatchedElementsFilterDFW::create(const std::string& input_field_name, uint32_t input_field_enum,
-                                 std::shared_ptr<StructFieldMapper> struct_field_mapper)
+                                 std::shared_ptr<MatchingElementsFields> matching_elems_fields)
 {
-    return std::make_unique<MatchedElementsFilterDFW>(input_field_name, input_field_enum, std::move(struct_field_mapper));
+    return std::make_unique<MatchedElementsFilterDFW>(input_field_name, input_field_enum, std::move(matching_elems_fields));
 }
 
 std::unique_ptr<IDocsumFieldWriter>
 MatchedElementsFilterDFW::create(const std::string& input_field_name, uint32_t input_field_enum,
                                  search::attribute::IAttributeContext& attr_ctx,
-                                 std::shared_ptr<StructFieldMapper> struct_field_mapper)
+                                 std::shared_ptr<MatchingElementsFields> matching_elems_fields)
 {
     StructFieldsResolver resolver(input_field_name, attr_ctx, false);
     if (resolver.has_error()) {
         return std::unique_ptr<IDocsumFieldWriter>();
     }
-    resolver.apply_to(*struct_field_mapper);
-    return std::make_unique<MatchedElementsFilterDFW>(input_field_name, input_field_enum, std::move(struct_field_mapper));
+    resolver.apply_to(*matching_elems_fields);
+    return std::make_unique<MatchedElementsFilterDFW>(input_field_name, input_field_enum, std::move(matching_elems_fields));
 }
 
 MatchedElementsFilterDFW::~MatchedElementsFilterDFW() = default;
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.h
index 966b5b95fa7..087ddfd8d40 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/matched_elements_filter_dfw.h
@@ -16,18 +16,18 @@ class MatchedElementsFilterDFW : public IDocsumFieldWriter {
 private:
     std::string _input_field_name;
     uint32_t _input_field_enum;
-    std::shared_ptr<StructFieldMapper> _struct_field_mapper;
+    std::shared_ptr<MatchingElementsFields> _matching_elems_fields;
 
     const std::vector<uint32_t>& get_matching_elements(uint32_t docid, GetDocsumsState& state) const;
 
 public:
     MatchedElementsFilterDFW(const std::string& input_field_name, uint32_t input_field_enum,
-                             std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                             std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     static std::unique_ptr<IDocsumFieldWriter> create(const std::string& input_field_name, uint32_t input_field_enum,
-                                                      std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                                                      std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     static std::unique_ptr<IDocsumFieldWriter> create(const std::string& input_field_name, uint32_t input_field_enum,
                                                       search::attribute::IAttributeContext& attr_ctx,
-                                                      std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                                                      std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     ~MatchedElementsFilterDFW();
     bool IsGenerated() const override { return false; }
     void insertField(uint32_t docid, GeneralResult* result, GetDocsumsState *state,
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.cpp b/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.cpp
index 749fc2941a6..9caad947335 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.cpp
@@ -2,7 +2,7 @@
 
 #include "struct_fields_resolver.h"
 #include <vespa/searchcommon/attribute/iattributecontext.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <algorithm>
 
 #include <vespa/log/log.h>
@@ -78,18 +78,18 @@ StructFieldsResolver::StructFieldsResolver(const vespalib::string& field_name, c
 StructFieldsResolver::~StructFieldsResolver() = default;
 
 void
-StructFieldsResolver::apply_to(StructFieldMapper& mapper) const
+StructFieldsResolver::apply_to(MatchingElementsFields& fields) const
 {
     if (is_map_of_struct()) {
         if (_has_map_key) {
-            mapper.add_mapping(_field_name, _map_key_attribute);
+            fields.add_mapping(_field_name, _map_key_attribute);
         }
         for (const auto& sub_field : _map_value_attributes) {
-            mapper.add_mapping(_field_name, sub_field);
+            fields.add_mapping(_field_name, sub_field);
         }
     } else {
         for (const auto& sub_field : _array_attributes) {
-            mapper.add_mapping(_field_name, sub_field);
+            fields.add_mapping(_field_name, sub_field);
         }
     }
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.h b/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.h
index b88e51a346b..e1db36d8a43 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_fields_resolver.h
@@ -7,7 +7,7 @@
 
 namespace search {
 namespace attribute { class IAttributeContext; }
-class StructFieldMapper;
+class MatchingElementsFields;
 }
 
 namespace search::docsummary {
@@ -45,7 +45,7 @@ public:
     const StringVector& get_array_fields() const { return _array_fields; }
     const StringVector& get_array_attributes() const { return _array_attributes; }
     bool has_error() const { return _error; }
-    void apply_to(StructFieldMapper& mapper) const;
+    void apply_to(MatchingElementsFields& fields) const;
 };
 
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
index 0a2c4726577..5344162b402 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
@@ -7,7 +7,7 @@
 #include <vespa/searchcommon/attribute/iattributecontext.h>
 #include <vespa/searchcommon/attribute/iattributevector.h>
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/data/slime/cursor.h>
 #include <cassert>
 
@@ -124,14 +124,14 @@ StructMapAttributeFieldWriterState::insertField(uint32_t docId, vespalib::slime:
 StructMapAttributeCombinerDFW::StructMapAttributeCombinerDFW(const vespalib::string &fieldName,
                                                              const StructFieldsResolver& fields_resolver,
                                                              bool filter_elements,
-                                                             std::shared_ptr<StructFieldMapper> struct_field_mapper)
-    : AttributeCombinerDFW(fieldName, filter_elements, std::move(struct_field_mapper)),
+                                                             std::shared_ptr<MatchingElementsFields> matching_elems_fields)
+    : AttributeCombinerDFW(fieldName, filter_elements, std::move(matching_elems_fields)),
       _keyAttributeName(fields_resolver.get_map_key_attribute()),
       _valueFields(fields_resolver.get_map_value_fields()),
       _valueAttributeNames(fields_resolver.get_map_value_attributes())
 {
-    if (filter_elements && _struct_field_mapper && !_struct_field_mapper->is_struct_field(fieldName)) {
-        fields_resolver.apply_to(*_struct_field_mapper);
+    if (filter_elements && _matching_elems_fields && !_matching_elems_fields->has_field(fieldName)) {
+        fields_resolver.apply_to(*_matching_elems_fields);
     }
 }
 
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
index a28e487fb1c..c2fdbebc0b6 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
@@ -26,7 +26,7 @@ public:
     StructMapAttributeCombinerDFW(const vespalib::string &fieldName,
                                   const StructFieldsResolver& fields_resolver,
                                   bool filter_elements,
-                                  std::shared_ptr<StructFieldMapper> struct_field_mapper);
+                                  std::shared_ptr<MatchingElementsFields> matching_elems_fields);
     ~StructMapAttributeCombinerDFW() override;
 };