Merge pull request #24651 from vespa-engine/geirst/attribute-builder-in-prod-features-tests

Use AttributeBuilder in prod features unit tests.

5 files changed, 93 insertions, 102 deletions

diff --git a/searchlib/src/tests/features/CMakeLists.txt b/searchlib/src/tests/features/CMakeLists.txt
index 1b61ccd014d..c5268e307ac 100644
--- a/searchlib/src/tests/features/CMakeLists.txt
+++ b/searchlib/src/tests/features/CMakeLists.txt
@@ -8,6 +8,7 @@ vespa_add_executable(searchlib_prod_features_test_app TEST
     prod_features_fieldtermmatch.cpp
     DEPENDS
     searchlib
+    searchlib_test
 )
 vespa_add_test(NAME searchlib_prod_features_test_app COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/prod_features_test.sh
                DEPENDS searchlib_prod_features_test_app COST 80)
diff --git a/searchlib/src/tests/features/prod_features.cpp b/searchlib/src/tests/features/prod_features.cpp
index f146abe5556..80650050b25 100644
--- a/searchlib/src/tests/features/prod_features.cpp
+++ b/searchlib/src/tests/features/prod_features.cpp
@@ -1,51 +1,52 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "prod_features.h"
-#include <vespa/searchlib/attribute/attributeguard.h>
+#include <vespa/searchcommon/attribute/config.h>
 #include <vespa/searchlib/attribute/attributefactory.h>
+#include <vespa/searchlib/attribute/attributeguard.h>
 #include <vespa/searchlib/attribute/attributevector.h>
 #include <vespa/searchlib/attribute/extendableattributes.h>
 #include <vespa/searchlib/attribute/floatbase.h>
 #include <vespa/searchlib/attribute/integerbase.h>
-#include <vespa/searchlib/attribute/stringbase.h>
 #include <vespa/searchlib/attribute/singleboolattribute.h>
+#include <vespa/searchlib/attribute/stringbase.h>
 #include <vespa/searchlib/features/agefeature.h>
 #include <vespa/searchlib/features/array_parser.hpp>
 #include <vespa/searchlib/features/attributefeature.h>
 #include <vespa/searchlib/features/closenessfeature.h>
 #include <vespa/searchlib/features/distancefeature.h>
-#include <vespa/searchlib/features/great_circle_distance_feature.h>
 #include <vespa/searchlib/features/dotproductfeature.h>
 #include <vespa/searchlib/features/fieldlengthfeature.h>
 #include <vespa/searchlib/features/fieldmatchfeature.h>
 #include <vespa/searchlib/features/firstphasefeature.h>
 #include <vespa/searchlib/features/foreachfeature.h>
 #include <vespa/searchlib/features/freshnessfeature.h>
+#include <vespa/searchlib/features/global_sequence_feature.h>
+#include <vespa/searchlib/features/great_circle_distance_feature.h>
 #include <vespa/searchlib/features/matchcountfeature.h>
 #include <vespa/searchlib/features/matchesfeature.h>
 #include <vespa/searchlib/features/matchfeature.h>
 #include <vespa/searchlib/features/nowfeature.h>
 #include <vespa/searchlib/features/queryfeature.h>
 #include <vespa/searchlib/features/querytermcountfeature.h>
-#include <vespa/searchlib/features/randomfeature.h>
 #include <vespa/searchlib/features/random_normal_feature.h>
 #include <vespa/searchlib/features/random_normal_stable_feature.h>
+#include <vespa/searchlib/features/randomfeature.h>
 #include <vespa/searchlib/features/rankingexpressionfeature.h>
 #include <vespa/searchlib/features/setup.h>
 #include <vespa/searchlib/features/termfeature.h>
 #include <vespa/searchlib/features/utils.h>
-#include <vespa/searchlib/features/global_sequence_feature.h>
 #include <vespa/searchlib/features/weighted_set_parser.hpp>
 #include <vespa/searchlib/fef/featurenamebuilder.h>
 #include <vespa/searchlib/fef/indexproperties.h>
 #include <vespa/searchlib/fef/queryproperties.h>
-#include <vespa/searchlib/fef/test/plugin/setup.h>
 #include <vespa/searchlib/fef/test/dummy_dependency_handler.h>
-#include <vespa/searchcommon/attribute/config.h>
-#include <vespa/vespalib/util/rand48.h>
-#include <vespa/vespalib/util/stringfmt.h>
+#include <vespa/searchlib/fef/test/plugin/setup.h>
+#include <vespa/searchlib/test/attribute_builder.h>
 #include <vespa/vespalib/geo/zcurve.h>
+#include <vespa/vespalib/util/rand48.h>
 #include <vespa/vespalib/util/string_hash.h>
+#include <vespa/vespalib/util/stringfmt.h>
 #include <cmath>
 
 #include <vespa/log/log.h>
@@ -55,14 +56,15 @@ using namespace search::features;
 using namespace search::fef;
 using namespace search::fef::test;
 
-using search::AttributeVector;
 using search::AttributeFactory;
-using search::IntegerAttribute;
+using search::AttributeVector;
 using search::FloatingPointAttribute;
-using search::StringAttribute;
+using search::IntegerAttribute;
 using search::SingleBoolAttribute;
+using search::StringAttribute;
 using search::WeightedSetStringExtAttribute;
 using search::attribute::WeightedEnumContent;
+using search::attribute::test::AttributeBuilder;
 using search::common::GeoLocation;
 using search::common::GeoLocationSpec;
 
@@ -211,15 +213,12 @@ Test::assertAge(feature_t expAge, const vespalib::string & attr, uint64_t now, u
 }
 
 void
-Test::setupForAgeTest(FtFeatureTest & ft, uint64_t docTime)
+Test::setupForAgeTest(FtFeatureTest & ft, int64_t docTime)
 {
-    AttributePtr doctime = AttributeFactory::createAttribute("doctime", AVC(AVBT::INT64,  AVCT::SINGLE));
+    auto doctime = AttributeBuilder("doctime", AVC(AVBT::INT64,  AVCT::SINGLE)).
+            fill({docTime}).get();
     ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::SINGLE, "doctime");
-    doctime->addReservedDoc();
-    doctime->addDocs(1);
     ft.getIndexEnv().getAttributeMap().add(doctime);
-    (dynamic_cast<IntegerAttribute *>(doctime.get()))->update(1, docTime);
-    doctime->commit();
 }
 
 void
@@ -949,8 +948,7 @@ Test::testDistance()
             }
             { // wrong attribute type (float)
                 FtFeatureTest ft(_factory, "distance(pos)");
-                AttributePtr pos = AttributeFactory::createAttribute("pos", AVC(AVBT::FLOAT,  AVCT::SINGLE));
-                pos->commit();
+                auto pos = AttributeBuilder("pos", AVC(AVBT::FLOAT,  AVCT::SINGLE)).get();
                 ft.getIndexEnv().getAttributeMap().add(pos);
                 ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::SINGLE, DataType::INT64, "pos");
                 GeoLocation::Point p{0, 0};
@@ -960,8 +958,7 @@ Test::testDistance()
             }
             { // wrong attribute type (string)
                 FtFeatureTest ft(_factory, "distance(pos)");
-                AttributePtr pos = AttributeFactory::createAttribute("pos", AVC(AVBT::STRING,  AVCT::SINGLE));
-                pos->commit();
+                auto pos = AttributeBuilder("pos", AVC(AVBT::STRING,  AVCT::SINGLE)).get();
                 ft.getIndexEnv().getAttributeMap().add(pos);
                 ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::SINGLE, DataType::INT64, "pos");
                 GeoLocation::Point p{0, 0};
@@ -971,8 +968,7 @@ Test::testDistance()
             }
             { // wrong attribute collection type (weighted set)
                 FtFeatureTest ft(_factory, "distance(pos)");
-                AttributePtr pos = AttributeFactory::createAttribute("pos", AVC(AVBT::INT64,  AVCT::WSET));
-                pos->commit();
+                auto pos = AttributeBuilder("pos", AVC(AVBT::INT64,  AVCT::WSET)).get();
                 ft.getIndexEnv().getAttributeMap().add(pos);
                 ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::WEIGHTEDSET, DataType::INT64, "pos");
                 GeoLocation::Point p{0, 0};
@@ -988,10 +984,7 @@ void
 Test::setupForDistanceTest(FtFeatureTest &ft, const vespalib::string & attrName,
                            const std::vector<std::pair<int32_t, int32_t> > & positions, bool zcurve)
 {
-    AttributePtr pos = AttributeFactory::createAttribute(attrName, AVC(AVBT::INT64,  AVCT::ARRAY));
-
-    pos->addReservedDoc();
-    pos->addDocs(1);
+    auto pos = AttributeBuilder(attrName, AVC(AVBT::INT64,  AVCT::ARRAY)).docs(1).get();
     ft.getIndexEnv().getAttributeMap().add(pos);
     ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::ARRAY, DataType::INT64, attrName);
 
@@ -1003,7 +996,6 @@ Test::setupForDistanceTest(FtFeatureTest &ft, const vespalib::string & attrName,
             ia->append(1, p.first, 0);
         }
     }
-
     pos->commit();
 }
 
@@ -1117,8 +1109,7 @@ Test::testDistanceToPath()
             {
                 // Wrong attribute type (float).
                 FtFeatureTest ft(_factory, "distanceToPath(pos)");
-                AttributePtr att = AttributeFactory::createAttribute("pos", AVC(AVBT::FLOAT, AVCT::SINGLE));
-                att->commit();
+                auto att = AttributeBuilder("pos", AVC(AVBT::FLOAT, AVCT::SINGLE)).get();
                 ft.getIndexEnv().getAttributeMap().add(att);
                 ft.getQueryEnv().getProperties().add("distanceToPath(pos).path", "0 0 1 1");
                 ASSERT_TRUE(ft.setup());
@@ -1127,8 +1118,7 @@ Test::testDistanceToPath()
             {
                 // Wrong attribute type (string).
                 FtFeatureTest ft(_factory, "distanceToPath(pos)");
-                AttributePtr att = AttributeFactory::createAttribute("pos", AVC(AVBT::STRING, AVCT::SINGLE));
-                att->commit();
+                auto att = AttributeBuilder("pos", AVC(AVBT::STRING, AVCT::SINGLE)).get();
                 ft.getIndexEnv().getAttributeMap().add(att);
                 ft.getQueryEnv().getProperties().add("distanceToPath(pos).path", "0 0 1 1");
                 ASSERT_TRUE(ft.setup());
@@ -1137,8 +1127,7 @@ Test::testDistanceToPath()
             {
                 // Wrong attribute collection type (weighted set).
                 FtFeatureTest ft(_factory, "distanceToPath(pos)");
-                AttributePtr att = AttributeFactory::createAttribute("pos", AVC(AVBT::INT64, AVCT::WSET));
-                att->commit();
+                auto att = AttributeBuilder("pos", AVC(AVBT::INT64, AVCT::WSET)).get();
                 ft.getIndexEnv().getAttributeMap().add(att);
                 ft.getQueryEnv().getProperties().add("distanceToPath(pos).path", "0 0 1 1");
                 ASSERT_TRUE(ft.setup());
@@ -1401,65 +1390,47 @@ Test::setupForDotProductTest(FtFeatureTest & ft)
                                     {"arrint_fast", AVBT::INT32, AVCT::ARRAY, true},
                                     {"arrfloat_fast", AVBT::FLOAT, AVCT::ARRAY, true}
                                   };
-    AttributePtr a = AttributeFactory::createAttribute("wsstr", AVC(AVBT::STRING, AVCT::WSET));
-    AttributePtr c = AttributeFactory::createAttribute("sint", AVC(AVBT::INT32, AVCT::SINGLE));
-    AttributePtr d(new search::WeightedSetStringExtAttribute("wsextstr"));
+    auto a = AttributeBuilder("wsstr", AVC(AVBT::STRING, AVCT::WSET)).
+            fill_wset({{{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}, {"e", 5}}, {}}).get();
+    auto c = AttributeBuilder("sint", AVC(AVBT::INT32, AVCT::SINGLE)).docs(2).get();
+    auto d = std::make_shared<search::WeightedSetStringExtAttribute>("wsextstr");
     ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::WEIGHTEDSET, "wsstr");
     ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::SINGLE, "sint");
     ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::WEIGHTEDSET, "wsextstr");
     for (const Config & cfg : cfgList) {
-        AttributePtr baf = AttributeFactory::createAttribute(cfg.name, AVC(cfg.dataType,
-                                                                           cfg.collectionType,
-                                                                           cfg.fastSearch));
+        AttributeBuilder builder(cfg.name, AVC(cfg.dataType,
+                                               cfg.collectionType,
+                                               cfg.fastSearch));
+        auto baf = builder.get();
         ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE,
                                                cfg.collectionType==AVCT::ARRAY
-                                                   ? CollectionType::ARRAY
-                                                   : CollectionType::WEIGHTEDSET,
+                                               ? CollectionType::ARRAY
+                                               : CollectionType::WEIGHTEDSET,
                                                cfg.name);
-        baf->addReservedDoc();
-        baf->addDocs(2);
         ft.getIndexEnv().getAttributeMap().add(baf);
-        for (size_t i(1); i < 6; i++) {
-            auto ia = dynamic_cast<IntegerAttribute *>(baf.get());
-            if (ia) {
-                ia->append(1, i, i);
-            } else {
-                auto fa = dynamic_cast<FloatingPointAttribute *>(baf.get());
-                fa->append(1, i, i);
-            }
+        if (baf->isIntegerType()) {
+            using WIL = AttributeBuilder::WeightedIntList;
+            builder.fill_wset({WIL{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}}, {}});
+        } else {
+            using WDL = AttributeBuilder::WeightedDoubleList;
+            builder.fill_wset({WDL{{1.0, 1}, {2.0, 2}, {3.0, 3}, {4.0, 4}, {5.0, 5}}, {}});
         }
-        baf->commit();
     }
 
-    a->addReservedDoc();
-    c->addReservedDoc();
-    a->addDocs(2);
-    c->addDocs(2);
     ft.getIndexEnv().getAttributeMap().add(a);
     ft.getIndexEnv().getAttributeMap().add(c);
     ft.getIndexEnv().getAttributeMap().add(d);
 
-    auto sa = dynamic_cast<StringAttribute *>(a.get());
-    sa->append(1, "a", 1);
-    sa->append(1, "b", 2);
-    sa->append(1, "c", 3);
-    sa->append(1, "d", 4);
-    sa->append(1, "e", 5);
-
-    auto ea = dynamic_cast<WeightedSetStringExtAttribute *>(d.get());
-    EXPECT_TRUE(!ea->hasEnum());
+    EXPECT_TRUE(!d->hasEnum());
     uint32_t docId;
-    ea->addDoc(docId);  // reserved doc
-    ea->addDoc(docId);
-    ea->add("a", 10);
-    ea->add("b", 20);
-    ea->add("c", 30);
-    ea->add("d", 40);
-    ea->add("e", 50);
-    ea->addDoc(docId);
-
-    a->commit();
-    c->commit();
+    d->addDoc(docId);  // reserved doc
+    d->addDoc(docId);
+    d->add("a", 10);
+    d->add("b", 20);
+    d->add("c", 30);
+    d->add("d", 40);
+    d->add("e", 50);
+    d->addDoc(docId);
 }
 
 void
diff --git a/searchlib/src/tests/features/prod_features.h b/searchlib/src/tests/features/prod_features.h
index ad21d7d7ccc..28b564b341e 100644
--- a/searchlib/src/tests/features/prod_features.h
+++ b/searchlib/src/tests/features/prod_features.h
@@ -82,7 +82,7 @@ private:
     void testFieldMatchExecutorRemaining();
 
     void assertAge(feature_t expAge, const vespalib::string & attr, uint64_t now, uint64_t docTime);
-    static void setupForAgeTest(FtFeatureTest & ft, uint64_t docTime);
+    static void setupForAgeTest(FtFeatureTest & ft, int64_t docTime);
     static void setupForAttributeTest(FtFeatureTest &ft, bool setup_env = true);
     void assertCloseness(feature_t exp, const vespalib::string & attr, double distance, double maxDistance = 0, double halfResponse = 0);
     static void setupForDistanceTest(FtFeatureTest & ft, const vespalib::string & attrName,
diff --git a/searchlib/src/vespa/searchlib/test/attribute_builder.cpp b/searchlib/src/vespa/searchlib/test/attribute_builder.cpp
index 4338a1e91b6..04d06cd4c66 100644
--- a/searchlib/src/vespa/searchlib/test/attribute_builder.cpp
+++ b/searchlib/src/vespa/searchlib/test/attribute_builder.cpp
@@ -14,12 +14,7 @@ AttributeBuilder::AttributeBuilder(const vespalib::string& name, const Config& c
     : _attr_ptr(AttributeFactory::createAttribute(name, cfg)),
       _attr(*_attr_ptr)
 {
-}
-
-AttributeBuilder::AttributeBuilder(AttributeVector& attr)
-    : _attr_ptr(),
-      _attr(attr)
-{
+    _attr.addReservedDoc();
 }
 
 namespace {
@@ -27,7 +22,6 @@ namespace {
 void
 add_docs(AttributeVector& attr, size_t num_docs)
 {
-    attr.addReservedDoc();
     attr.addDocs(num_docs);
 }
 
@@ -48,8 +42,7 @@ template <typename AttrType, typename ValueType>
 void
 fill_array_helper(AttributeVector& attr, std::initializer_list<std::initializer_list<ValueType>> values)
 {
-    assert((attr.getConfig().collectionType() == CollectionType::ARRAY) ||
-           (attr.getConfig().collectionType() == CollectionType::WSET));
+    assert(attr.hasMultiValue());
     add_docs(attr, values.size());
     auto& real = dynamic_cast<AttrType&>(attr);
     uint32_t docid = 1;
@@ -66,7 +59,7 @@ template <typename AttrType, typename ValueType>
 void
 fill_wset_helper(AttributeVector& attr, std::initializer_list<std::initializer_list<std::pair<ValueType, int32_t>>> values)
 {
-    assert(attr.getConfig().collectionType() == CollectionType::WSET);
+    assert(attr.hasMultiValue());
     add_docs(attr, values.size());
     auto& real = dynamic_cast<AttrType&>(attr);
     uint32_t docid = 1;
@@ -82,6 +75,13 @@ fill_wset_helper(AttributeVector& attr, std::initializer_list<std::initializer_l
 }
 
 AttributeBuilder&
+AttributeBuilder::docs(size_t num_docs)
+{
+    add_docs(_attr, num_docs);
+    return *this;
+}
+
+AttributeBuilder&
 AttributeBuilder::fill(std::initializer_list<int32_t> values)
 {
     fill_helper<IntegerAttribute, int32_t>(_attr, values);
@@ -89,14 +89,21 @@ AttributeBuilder::fill(std::initializer_list<int32_t> values)
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_array(std::initializer_list<std::initializer_list<int32_t>> values)
+AttributeBuilder::fill(std::initializer_list<int64_t> values)
+{
+    fill_helper<IntegerAttribute, int64_t>(_attr, values);
+    return *this;
+}
+
+AttributeBuilder&
+AttributeBuilder::fill_array(std::initializer_list<IntList> values)
 {
     fill_array_helper<IntegerAttribute, int32_t>(_attr, values);
     return *this;
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_wset(std::initializer_list<std::initializer_list<std::pair<int32_t, int32_t>>> values)
+AttributeBuilder::fill_wset(std::initializer_list<WeightedIntList> values)
 {
     fill_wset_helper<IntegerAttribute, int32_t>(_attr, values);
     return *this;
@@ -110,14 +117,14 @@ AttributeBuilder::fill(std::initializer_list<double> values)
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_array(std::initializer_list<std::initializer_list<double>> values)
+AttributeBuilder::fill_array(std::initializer_list<DoubleList> values)
 {
     fill_array_helper<FloatingPointAttribute, double>(_attr, values);
     return *this;
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_wset(std::initializer_list<std::initializer_list<std::pair<double, int32_t>>> values)
+AttributeBuilder::fill_wset(std::initializer_list<WeightedDoubleList> values)
 {
     fill_wset_helper<FloatingPointAttribute, double>(_attr, values);
     return *this;
@@ -131,14 +138,14 @@ AttributeBuilder::fill(std::initializer_list<vespalib::string> values)
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_array(std::initializer_list<std::initializer_list<vespalib::string>> values)
+AttributeBuilder::fill_array(std::initializer_list<StringList> values)
 {
     fill_array_helper<StringAttribute, vespalib::string>(_attr, values);
     return *this;
 }
 
 AttributeBuilder&
-AttributeBuilder::fill_wset(std::initializer_list<std::initializer_list<std::pair<vespalib::string, int32_t>>> values)
+AttributeBuilder::fill_wset(std::initializer_list<WeightedStringList> values)
 {
     fill_wset_helper<StringAttribute, vespalib::string>(_attr, values);
     return *this;
diff --git a/searchlib/src/vespa/searchlib/test/attribute_builder.h b/searchlib/src/vespa/searchlib/test/attribute_builder.h
index 255a14ee72d..d5c2c3aa90e 100644
--- a/searchlib/src/vespa/searchlib/test/attribute_builder.h
+++ b/searchlib/src/vespa/searchlib/test/attribute_builder.h
@@ -22,23 +22,35 @@ private:
     AttributeVector& _attr;
 
 public:
+    using WeightedInt = std::pair<int32_t, int32_t>;
+    using WeightedDouble = std::pair<double, int32_t>;
+    using WeightedString = std::pair<vespalib::string, int32_t>;
+    using IntList = std::initializer_list<int32_t>;
+    using DoubleList = std::initializer_list<double>;
+    using StringList = std::initializer_list<vespalib::string>;
+    using WeightedIntList = std::initializer_list<WeightedInt>;
+    using WeightedDoubleList = std::initializer_list<WeightedDouble>;
+    using WeightedStringList = std::initializer_list<WeightedString>;
+
     AttributeBuilder(const vespalib::string& name, const Config& cfg);
-    AttributeBuilder(AttributeVector& attr);
+
+    AttributeBuilder& docs(size_t num_docs);
 
     // Fill functions for integer attributes
     AttributeBuilder& fill(std::initializer_list<int32_t> values);
-    AttributeBuilder& fill_array(std::initializer_list<std::initializer_list<int32_t>> values);
-    AttributeBuilder& fill_wset(std::initializer_list<std::initializer_list<std::pair<int32_t, int32_t>>> values);
+    AttributeBuilder& fill(std::initializer_list<int64_t> values);
+    AttributeBuilder& fill_array(std::initializer_list<IntList> values);
+    AttributeBuilder& fill_wset(std::initializer_list<WeightedIntList> values);
 
     // Fill functions for float attributes
     AttributeBuilder& fill(std::initializer_list<double> values);
-    AttributeBuilder& fill_array(std::initializer_list<std::initializer_list<double>> values);
-    AttributeBuilder& fill_wset(std::initializer_list<std::initializer_list<std::pair<double, int32_t>>> values);
+    AttributeBuilder& fill_array(std::initializer_list<DoubleList> values);
+    AttributeBuilder& fill_wset(std::initializer_list<WeightedDoubleList> values);
 
     // Fill functions for string attributes
     AttributeBuilder& fill(std::initializer_list<vespalib::string> values);
-    AttributeBuilder& fill_array(std::initializer_list<std::initializer_list<vespalib::string>> values);
-    AttributeBuilder& fill_wset(std::initializer_list<std::initializer_list<std::pair<vespalib::string, int32_t>>> values);
+    AttributeBuilder& fill_array(std::initializer_list<StringList> values);
+    AttributeBuilder& fill_wset(std::initializer_list<WeightedStringList> values);
 
     std::shared_ptr<AttributeVector> get() const { return _attr_ptr; }
 };