Merge pull request #10646 from vespa-engine/geirst/enum-store-cleanup-5

Geirst/enum store cleanup 5.

31 files changed, 250 insertions, 286 deletions

diff --git a/searchlib/src/tests/attribute/enum_comparator/enum_comparator_test.cpp b/searchlib/src/tests/attribute/enum_comparator/enum_comparator_test.cpp
index 97b08c5683f..4a7491130f4 100644
--- a/searchlib/src/tests/attribute/enum_comparator/enum_comparator_test.cpp
+++ b/searchlib/src/tests/attribute/enum_comparator/enum_comparator_test.cpp
@@ -107,7 +107,7 @@ Test::requireThatComparatorWithTreeIsWorking()
     EXPECT_EQUAL(100u, t.size(m));
     int32_t exp = 1;
     for (TreeType::Iterator itr = t.begin(m); itr.valid(); ++itr) {
-        EXPECT_EQUAL(exp++, es.getValue(itr.getKey()));
+        EXPECT_EQUAL(exp++, es.get_value(itr.getKey()));
     }
     EXPECT_EQUAL(101, exp);
     t.clear(m);
diff --git a/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp b/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
index cd02c099f1f..7ad3227917b 100644
--- a/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
+++ b/searchlib/src/tests/attribute/enumstore/enumstore_test.cpp
@@ -53,7 +53,7 @@ checkReaders(const StringEnumStore& ses,
     for (uint32_t i = 0; i < readers.size(); ++i) {
         const Reader& r = readers[i];
         for (uint32_t j = 0; j < r._indices.size(); ++j) {
-            EXPECT_TRUE(ses.getValue(r._indices[j], t));
+            EXPECT_TRUE(ses.get_value(r._indices[j], t));
             EXPECT_TRUE(r._expected[j]._string == std::string(t));
         }
     }
@@ -90,17 +90,17 @@ TYPED_TEST(FloatEnumStoreTest, numbers_can_be_inserted_and_retrieved)
     }
 
     for (uint32_t i = 0; i < 5; ++i) {
-        EXPECT_TRUE(this->es.findIndex(a[i], idx));
-        EXPECT_TRUE(!this->es.findIndex(b[i], idx));
+        EXPECT_TRUE(this->es.find_index(a[i], idx));
+        EXPECT_TRUE(!this->es.find_index(b[i], idx));
     }
 
     this->es.insert(std::numeric_limits<EntryType>::quiet_NaN());
-    EXPECT_TRUE(this->es.findIndex(std::numeric_limits<EntryType>::quiet_NaN(), idx));
-    EXPECT_TRUE(this->es.findIndex(std::numeric_limits<EntryType>::quiet_NaN(), idx));
+    EXPECT_TRUE(this->es.find_index(std::numeric_limits<EntryType>::quiet_NaN(), idx));
+    EXPECT_TRUE(this->es.find_index(std::numeric_limits<EntryType>::quiet_NaN(), idx));
 
     for (uint32_t i = 0; i < 5; ++i) {
-        EXPECT_TRUE(this->es.findIndex(a[i], idx));
-        EXPECT_TRUE(!this->es.findIndex(b[i], idx));
+        EXPECT_TRUE(this->es.find_index(a[i], idx));
+        EXPECT_TRUE(!this->es.find_index(b[i], idx));
     }
 }
 
@@ -114,39 +114,39 @@ TEST(EnumStoreTest, test_find_folded_on_string_enum_store)
     for (std::string &str : unique) {
         EnumIndex idx = ses.insert(str.c_str());
         indices.push_back(idx);
-        EXPECT_EQ(1u, ses.getRefCount(idx));
+        EXPECT_EQ(1u, ses.get_ref_count(idx));
     }
-    ses.freezeTree();
+    ses.freeze_dictionary();
     for (uint32_t i = 0; i < indices.size(); ++i) {
         EnumIndex idx;
-        EXPECT_TRUE(ses.findIndex(unique[i].c_str(), idx));
+        EXPECT_TRUE(ses.find_index(unique[i].c_str(), idx));
     }
-    EXPECT_EQ(1u, ses.findFoldedEnums("").size());
-    EXPECT_EQ(0u, ses.findFoldedEnums("foo").size());
-    EXPECT_EQ(1u, ses.findFoldedEnums("one").size());
-    EXPECT_EQ(3u, ses.findFoldedEnums("two").size());
-    EXPECT_EQ(3u, ses.findFoldedEnums("TWO").size());
-    EXPECT_EQ(3u, ses.findFoldedEnums("tWo").size());
-    const auto v = ses.findFoldedEnums("Two");
-    EXPECT_EQ(std::string("TWO"), ses.getValue(v[0]));
-    EXPECT_EQ(std::string("Two"), ses.getValue(v[1]));
-    EXPECT_EQ(std::string("two"), ses.getValue(v[2]));
-    EXPECT_EQ(1u, ses.findFoldedEnums("three").size());
+    EXPECT_EQ(1u, ses.find_folded_enums("").size());
+    EXPECT_EQ(0u, ses.find_folded_enums("foo").size());
+    EXPECT_EQ(1u, ses.find_folded_enums("one").size());
+    EXPECT_EQ(3u, ses.find_folded_enums("two").size());
+    EXPECT_EQ(3u, ses.find_folded_enums("TWO").size());
+    EXPECT_EQ(3u, ses.find_folded_enums("tWo").size());
+    const auto v = ses.find_folded_enums("Two");
+    EXPECT_EQ(std::string("TWO"), ses.get_value(v[0]));
+    EXPECT_EQ(std::string("Two"), ses.get_value(v[1]));
+    EXPECT_EQ(std::string("two"), ses.get_value(v[2]));
+    EXPECT_EQ(1u, ses.find_folded_enums("three").size());
 }
 
 template <typename DictionaryT>
 void
 testUniques(const StringEnumStore& ses, const std::vector<std::string>& unique)
 {
-    const auto* enumDict = dynamic_cast<const EnumStoreDictionary<DictionaryT>*>(&ses.getEnumStoreDict());
+    const auto* enumDict = dynamic_cast<const EnumStoreDictionary<DictionaryT>*>(&ses.get_dictionary());
     assert(enumDict != nullptr);
-    const DictionaryT& dict = enumDict->getDictionary();
+    const DictionaryT& dict = enumDict->get_raw_dictionary();
     uint32_t i = 0;
     EnumIndex idx;
     for (typename DictionaryT::Iterator iter = dict.begin();
          iter.valid(); ++iter, ++i) {
         idx = iter.getKey();
-        EXPECT_TRUE(strcmp(unique[i].c_str(), ses.getValue(idx)) == 0);
+        EXPECT_TRUE(strcmp(unique[i].c_str(), ses.get_value(idx)) == 0);
     }
     EXPECT_EQ(static_cast<uint32_t>(unique.size()), i);
 }
@@ -170,23 +170,23 @@ StringEnumStoreTest::testInsert(bool hasPostings)
 
     for (uint32_t i = 0; i < unique.size(); ++i) {
         EnumIndex idx = ses.insert(unique[i].c_str());
-        EXPECT_EQ(1u, ses.getRefCount(idx));
+        EXPECT_EQ(1u, ses.get_ref_count(idx));
         indices.push_back(idx);
-        EXPECT_TRUE(ses.findIndex(unique[i].c_str(), idx));
+        EXPECT_TRUE(ses.find_index(unique[i].c_str(), idx));
     }
-    ses.freezeTree();
+    ses.freeze_dictionary();
 
     for (uint32_t i = 0; i < indices.size(); ++i) {
         uint32_t e = 0;
-        EXPECT_TRUE(ses.findEnum(unique[i].c_str(), e));
-        EXPECT_EQ(1u, ses.findFoldedEnums(unique[i].c_str()).size());
-        EXPECT_EQ(e, ses.findFoldedEnums(unique[i].c_str())[0]);
+        EXPECT_TRUE(ses.find_enum(unique[i].c_str(), e));
+        EXPECT_EQ(1u, ses.find_folded_enums(unique[i].c_str()).size());
+        EXPECT_EQ(e, ses.find_folded_enums(unique[i].c_str())[0]);
         EnumIndex idx;
-        EXPECT_TRUE(ses.findIndex(unique[i].c_str(), idx));
+        EXPECT_TRUE(ses.find_index(unique[i].c_str(), idx));
         EXPECT_TRUE(idx == indices[i]);
-        EXPECT_EQ(1u, ses.getRefCount(indices[i]));
+        EXPECT_EQ(1u, ses.get_ref_count(indices[i]));
         const char* value = nullptr;
-        EXPECT_TRUE(ses.getValue(indices[i], value));
+        EXPECT_TRUE(ses.get_value(indices[i], value));
         EXPECT_TRUE(strcmp(unique[i].c_str(), value) == 0);
     }
 
@@ -231,17 +231,17 @@ TEST(EnumStoreTest, test_hold_lists_and_generation)
     // insert first batch of unique strings
     for (uint32_t i = 0; i < 100; ++i) {
         EnumIndex idx = ses.insert(uniques[i].c_str());
-        EXPECT_TRUE(ses.getRefCount(idx));
+        EXPECT_TRUE(ses.get_ref_count(idx));
 
         // associate readers
         if (i % 10 == 9) {
             Reader::IndexVector indices;
             Reader::ExpectedVector expected;
             for (uint32_t j = i - 9; j <= i; ++j) {
-                EXPECT_TRUE(ses.findIndex(uniques[j].c_str(), idx));
+                EXPECT_TRUE(ses.find_index(uniques[j].c_str(), idx));
                 indices.push_back(idx);
-                uint32_t ref_count = ses.getRefCount(idx);
-                std::string value(ses.getValue(idx));
+                uint32_t ref_count = ses.get_ref_count(idx);
+                std::string value(ses.get_value(idx));
                 EXPECT_EQ(1u, ref_count);
                 EXPECT_EQ(uniques[j], value);
                 expected.emplace_back(ref_count, value);
@@ -258,17 +258,17 @@ TEST(EnumStoreTest, test_hold_lists_and_generation)
     auto updater = ses.make_batch_updater();
     for (uint32_t i = 0; i < 100; ++i) {
         EnumIndex idx;
-        EXPECT_TRUE(ses.findIndex(uniques[i].c_str(), idx));
+        EXPECT_TRUE(ses.find_index(uniques[i].c_str(), idx));
         updater.dec_ref_count(idx);
-        EXPECT_EQ(0u, ses.getRefCount(idx));
+        EXPECT_EQ(0u, ses.get_ref_count(idx));
     }
     updater.commit();
 
     // check readers again
     checkReaders(ses, readers);
 
-    ses.transferHoldLists(sesGen);
-    ses.trimHoldLists(sesGen + 1);
+    ses.transfer_hold_lists(sesGen);
+    ses.trim_hold_lists(sesGen + 1);
 }
 
 void
@@ -279,8 +279,8 @@ dec_ref_count(NumericEnumStore& store, NumericEnumStore::Index idx)
     updater.commit();
 
     generation_t gen = 5;
-    store.transferHoldLists(gen);
-    store.trimHoldLists(gen + 1);
+    store.transfer_hold_lists(gen);
+    store.trim_hold_lists(gen + 1);
 }
 
 TEST(EnumStoreTest, address_space_usage_is_reported)
@@ -289,16 +289,16 @@ TEST(EnumStoreTest, address_space_usage_is_reported)
     NumericEnumStore store(false);
 
     using vespalib::AddressSpace;
-    EXPECT_EQ(AddressSpace(1, 1, ADDRESS_LIMIT), store.getAddressSpaceUsage());
+    EXPECT_EQ(AddressSpace(1, 1, ADDRESS_LIMIT), store.get_address_space_usage());
     EnumIndex idx1 = store.insert(10);
-    EXPECT_EQ(AddressSpace(2, 1, ADDRESS_LIMIT), store.getAddressSpaceUsage());
+    EXPECT_EQ(AddressSpace(2, 1, ADDRESS_LIMIT), store.get_address_space_usage());
     EnumIndex idx2 = store.insert(20);
     // Address limit increases because buffer is re-sized.
-    EXPECT_EQ(AddressSpace(3, 1, ADDRESS_LIMIT + 2), store.getAddressSpaceUsage());
+    EXPECT_EQ(AddressSpace(3, 1, ADDRESS_LIMIT + 2), store.get_address_space_usage());
     dec_ref_count(store, idx1);
-    EXPECT_EQ(AddressSpace(3, 2, ADDRESS_LIMIT + 2), store.getAddressSpaceUsage());
+    EXPECT_EQ(AddressSpace(3, 2, ADDRESS_LIMIT + 2), store.get_address_space_usage());
     dec_ref_count(store, idx2);
-    EXPECT_EQ(AddressSpace(3, 3, ADDRESS_LIMIT + 2), store.getAddressSpaceUsage());
+    EXPECT_EQ(AddressSpace(3, 3, ADDRESS_LIMIT + 2), store.get_address_space_usage());
 }
 
 class BatchUpdaterTest : public ::testing::Test {
@@ -325,16 +325,16 @@ public:
 
     void expect_value_in_store(int32_t exp_value, uint32_t exp_ref_count, EnumIndex idx) {
         EnumIndex tmp_idx;
-        EXPECT_TRUE(store.findIndex(exp_value, tmp_idx));
+        EXPECT_TRUE(store.find_index(exp_value, tmp_idx));
         EXPECT_EQ(idx, tmp_idx);
-        EXPECT_EQ(exp_value, store.getValue(idx));
-        EXPECT_EQ(exp_ref_count, store.getRefCount(idx));
+        EXPECT_EQ(exp_value, store.get_value(idx));
+        EXPECT_EQ(exp_ref_count, store.get_ref_count(idx));
     }
 
     void expect_value_not_in_store(int32_t value, EnumIndex idx) {
         EnumIndex temp_idx;
-        EXPECT_FALSE(store.findIndex(value, idx));
-        EXPECT_EQ(0, store.getRefCount(idx));
+        EXPECT_FALSE(store.find_index(value, idx));
+        EXPECT_EQ(0, store.get_ref_count(idx));
     }
 };
 
@@ -395,7 +395,7 @@ public:
 
     EnumIndex find_index(size_t values_idx) const {
         EnumIndex result;
-        EXPECT_TRUE(store.findIndex(values[values_idx], result));
+        EXPECT_TRUE(store.find_index(values[values_idx], result));
         return result;
     }
 
@@ -406,12 +406,12 @@ public:
 
     void expect_value_in_store(size_t values_idx, uint32_t exp_ref_count) const {
         EnumIndex idx = find_index(values_idx);
-        EXPECT_EQ(exp_ref_count, store.getRefCount(idx));
+        EXPECT_EQ(exp_ref_count, store.get_ref_count(idx));
     }
 
     void expect_value_not_in_store(size_t values_idx) const {
         EnumIndex idx;
-        EXPECT_FALSE(store.findIndex(values[values_idx], idx));
+        EXPECT_FALSE(store.find_index(values[values_idx], idx));
     }
 
     void expect_values_in_store() {
@@ -423,7 +423,7 @@ public:
 
     void expect_posting_idx(size_t values_idx, uint32_t exp_posting_idx) const {
         auto cmp = store.make_comparator();
-        auto itr = store.getPostingDictionary().find(find_index(values_idx), cmp);
+        auto itr = store.get_posting_dictionary().find(find_index(values_idx), cmp);
         ASSERT_TRUE(itr.valid());
         EXPECT_EQ(exp_posting_idx, itr.getData());
     }
@@ -477,7 +477,7 @@ TYPED_TEST(LoaderTest, store_is_instantiated_with_enumerated_postings_loader)
     this->set_ref_count(0, 1, loader);
     this->set_ref_count(1, 2, loader);
     this->set_ref_count(3, 4, loader);
-    loader.free_unused_enums();
+    loader.free_unused_values();
 
     this->expect_values_in_store();
 }
diff --git a/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp b/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
index 2be779cb41d..9b4c72e1027 100644
--- a/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
+++ b/searchlib/src/tests/attribute/postinglistattribute/postinglistattribute_test.cpp
@@ -445,7 +445,7 @@ PostingListAttributeTest::checkPostingList(const VectorType & vec, const std::ve
                                            const RangeGenerator & range)
 {
     const typename VectorType::EnumStore & enumStore = vec.getEnumStore();
-    const typename VectorType::Dictionary & dict = enumStore.getPostingDictionary();
+    const typename VectorType::Dictionary & dict = enumStore.get_posting_dictionary();
     const typename VectorType::PostingList & postingList = vec.getPostingList();
 
     for (size_t i = 0; i < values.size(); ++i) {
@@ -669,7 +669,7 @@ void
 PostingListAttributeTest::checkPostingList(AttributeType & vec, ValueType value, DocSet expected)
 {
     const typename AttributeType::EnumStore & enumStore = vec.getEnumStore();
-    const typename AttributeType::Dictionary & dict = enumStore.getPostingDictionary();
+    const typename AttributeType::Dictionary & dict = enumStore.get_posting_dictionary();
     const typename AttributeType::PostingList & postingList = vec.getPostingList();
     auto itr = dict.find(typename AttributeType::EnumIndex(),
                          vec.getEnumStore().make_comparator(value));
@@ -690,7 +690,7 @@ template <typename AttributeType, typename ValueType>
 void
 PostingListAttributeTest::checkNonExistantPostingList(AttributeType & vec, ValueType value)
 {
-    const typename AttributeType::Dictionary & dict = vec.getEnumStore().getPostingDictionary();
+    const typename AttributeType::Dictionary & dict = vec.getEnumStore().get_posting_dictionary();
     auto itr = dict.find(typename AttributeType::EnumIndex(),
                          vec.getEnumStore().make_comparator(value));
     EXPECT_TRUE(!itr.valid());
diff --git a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
index dcf246033ba..5c73a60f6ef 100644
--- a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
+++ b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
@@ -177,9 +177,9 @@ StringAttributeTest::testMultiValue(Attribute & attr, uint32_t numDocs)
     // check for correct refcounts
     for (uint32_t i = 0; i < uniqueStrings.size(); ++i) {
         typename Attribute::EnumStore::Index idx;
-        EXPECT_TRUE(attr.getEnumStore().findIndex(uniqueStrings[i].c_str(), idx));
+        EXPECT_TRUE(attr.getEnumStore().find_index(uniqueStrings[i].c_str(), idx));
         uint32_t expectedUsers = numDocs - 1 - i;
-        EXPECT_EQUAL(expectedUsers, attr.getEnumStore().getRefCount(idx));
+        EXPECT_EQUAL(expectedUsers, attr.getEnumStore().get_ref_count(idx));
     }
 
     // clear and insert new unique strings
@@ -225,9 +225,9 @@ StringAttributeTest::testMultiValue(Attribute & attr, uint32_t numDocs)
     // check for correct refcounts
     for (uint32_t i = 0; i < newUniques.size(); ++i) {
         typename Attribute::EnumStore::Index idx;
-        EXPECT_TRUE(attr.getEnumStore().findIndex(newUniques[i].c_str(), idx));
+        EXPECT_TRUE(attr.getEnumStore().find_index(newUniques[i].c_str(), idx));
         uint32_t expectedUsers = numDocs - 1 - i;
-        EXPECT_EQUAL(expectedUsers, attr.getEnumStore().getRefCount(idx));
+        EXPECT_EQUAL(expectedUsers, attr.getEnumStore().get_ref_count(idx));
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.cpp b/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.cpp
index 3e85b8021b7..2a544814710 100644
--- a/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.cpp
@@ -23,71 +23,64 @@ namespace search {
 using btree::BTreeNode;
 
 template <typename DictionaryT>
-EnumStoreDictionary<DictionaryT>::EnumStoreDictionary(IEnumStore& enumStore)
-    : ParentUniqueStoreDictionary(),
-      _enumStore(enumStore)
+void
+EnumStoreDictionary<DictionaryT>::remove_unused_values(const IndexSet& unused,
+                                                       const datastore::EntryComparator& cmp)
 {
+    if (unused.empty()) {
+        return;
+    }
+    for (const auto& ref : unused) {
+        this->remove(cmp, ref);
+    }
 }
 
 template <typename DictionaryT>
-EnumStoreDictionary<DictionaryT>::~EnumStoreDictionary() = default;
-
-template <typename DictionaryT>
-uint32_t
-EnumStoreDictionary<DictionaryT>::getNumUniques() const
+EnumStoreDictionary<DictionaryT>::EnumStoreDictionary(IEnumStore& enumStore)
+    : ParentUniqueStoreDictionary(),
+      _enumStore(enumStore)
 {
-    return this->_dict.size();
 }
 
 template <typename DictionaryT>
-void
-EnumStoreDictionary<DictionaryT>::fixupRefCounts(const EnumVector& hist)
-{
-    _enumStore.fixupRefCounts(hist, this->_dict);
-}
+EnumStoreDictionary<DictionaryT>::~EnumStoreDictionary() = default;
 
 template <typename DictionaryT>
 void
-EnumStoreDictionary<DictionaryT>::removeUnusedEnums(const IndexSet& unused,
-                                                    const datastore::EntryComparator& cmp)
+EnumStoreDictionary<DictionaryT>::set_ref_counts(const EnumVector& hist)
 {
-    if (unused.empty()) {
-        return;
-    }
-    for (const auto& ref : unused) {
-        this->remove(cmp, ref);
-    }
+    _enumStore.set_ref_counts(hist, this->_dict);
 }
 
 template <typename DictionaryT>
 void
-EnumStoreDictionary<DictionaryT>::freeUnusedEnums(const datastore::EntryComparator& cmp)
+EnumStoreDictionary<DictionaryT>::free_unused_values(const datastore::EntryComparator& cmp)
 {
     IndexSet unused;
 
     // find unused enums
     for (auto iter = this->_dict.begin(); iter.valid(); ++iter) {
-        _enumStore.freeUnusedEnum(iter.getKey(), unused);
+        _enumStore.free_value_if_unused(iter.getKey(), unused);
     }
-    removeUnusedEnums(unused, cmp);
+    remove_unused_values(unused, cmp);
 }
 
 template <typename DictionaryT>
 void
-EnumStoreDictionary<DictionaryT>::freeUnusedEnums(const IndexSet& toRemove,
-                                                  const datastore::EntryComparator& cmp)
+EnumStoreDictionary<DictionaryT>::free_unused_values(const IndexSet& to_remove,
+                                                     const datastore::EntryComparator& cmp)
 {
     IndexSet unused;
-    for (const auto& index : toRemove) {
-        _enumStore.freeUnusedEnum(index, unused);
+    for (const auto& index : to_remove) {
+        _enumStore.free_value_if_unused(index, unused);
     }
-    removeUnusedEnums(unused, cmp);
+    remove_unused_values(unused, cmp);
 }
 
 template <typename DictionaryT>
 bool
-EnumStoreDictionary<DictionaryT>::findIndex(const datastore::EntryComparator& cmp,
-                                            Index& idx) const
+EnumStoreDictionary<DictionaryT>::find_index(const datastore::EntryComparator& cmp,
+                                             Index& idx) const
 {
     auto itr = this->_dict.find(Index(), cmp);
     if (!itr.valid()) {
@@ -99,8 +92,8 @@ EnumStoreDictionary<DictionaryT>::findIndex(const datastore::EntryComparator& cm
 
 template <typename DictionaryT>
 bool
-EnumStoreDictionary<DictionaryT>::findFrozenIndex(const datastore::EntryComparator& cmp,
-                                                  Index& idx) const
+EnumStoreDictionary<DictionaryT>::find_frozen_index(const datastore::EntryComparator& cmp,
+                                                    Index& idx) const
 {
     auto itr = this->_dict.getFrozenView().find(Index(), cmp);
     if (!itr.valid()) {
@@ -112,7 +105,7 @@ EnumStoreDictionary<DictionaryT>::findFrozenIndex(const datastore::EntryComparat
 
 template <typename DictionaryT>
 std::vector<IEnumStore::EnumHandle>
-EnumStoreDictionary<DictionaryT>::findMatchingEnums(const datastore::EntryComparator& cmp) const
+EnumStoreDictionary<DictionaryT>::find_matching_enums(const datastore::EntryComparator& cmp) const
 {
     std::vector<IEnumStore::EnumHandle> result;
     auto itr = this->_dict.getFrozenView().find(Index(), cmp);
@@ -123,48 +116,34 @@ EnumStoreDictionary<DictionaryT>::findMatchingEnums(const datastore::EntryCompar
     return result;
 }
 
-template <typename DictionaryT>
-void
-EnumStoreDictionary<DictionaryT>::onReset()
-{
-    this->_dict.clear();
-}
-
 template <>
 EnumPostingTree &
-EnumStoreDictionary<EnumTree>::getPostingDictionary()
+EnumStoreDictionary<EnumTree>::get_posting_dictionary()
 {
     LOG_ABORT("should not be reached");
 }
 
 template <>
 EnumPostingTree &
-EnumStoreDictionary<EnumPostingTree>::getPostingDictionary()
+EnumStoreDictionary<EnumPostingTree>::get_posting_dictionary()
 {
     return _dict;
 }
 
 template <>
 const EnumPostingTree &
-EnumStoreDictionary<EnumTree>::getPostingDictionary() const
+EnumStoreDictionary<EnumTree>::get_posting_dictionary() const
 {
     LOG_ABORT("should not be reached");
 }
 
 template <>
 const EnumPostingTree &
-EnumStoreDictionary<EnumPostingTree>::getPostingDictionary() const
+EnumStoreDictionary<EnumPostingTree>::get_posting_dictionary() const
 {
     return _dict;
 }
 
-template <typename DictionaryT>
-bool
-EnumStoreDictionary<DictionaryT>::hasData() const
-{
-    return DictionaryT::LeafNodeType::hasData();
-}
-
 EnumStoreFoldedDictionary::EnumStoreFoldedDictionary(IEnumStore& enumStore, std::unique_ptr<EntryComparator> folded_compare)
     : EnumStoreDictionary<EnumPostingTree>(enumStore),
       _folded_compare(std::move(folded_compare))
@@ -174,7 +153,7 @@ EnumStoreFoldedDictionary::EnumStoreFoldedDictionary(IEnumStore& enumStore, std:
 EnumStoreFoldedDictionary::~EnumStoreFoldedDictionary() = default;
 
 UniqueStoreAddResult
-EnumStoreFoldedDictionary::add(const EntryComparator &comp, std::function<EntryRef(void)> insertEntry)
+EnumStoreFoldedDictionary::add(const EntryComparator& comp, std::function<EntryRef(void)> insertEntry)
 {
     auto it = _dict.lowerBound(EntryRef(), comp);
     if (it.valid() && !comp(EntryRef(), it.getKey())) {
@@ -197,7 +176,7 @@ EnumStoreFoldedDictionary::add(const EntryComparator &comp, std::function<EntryR
 }
 
 void
-EnumStoreFoldedDictionary::remove(const EntryComparator &comp, EntryRef ref)
+EnumStoreFoldedDictionary::remove(const EntryComparator& comp, EntryRef ref)
 {
     assert(ref.valid());
     auto it = _dict.lowerBound(ref, comp);
diff --git a/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.h b/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.h
index 05c3366b1d1..5e7a63e68b4 100644
--- a/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.h
+++ b/searchlib/src/vespa/searchlib/attribute/enum_store_dictionary.h
@@ -24,36 +24,30 @@ private:
 
     IEnumStore& _enumStore;
 
+    void remove_unused_values(const IndexSet& unused,
+                              const datastore::EntryComparator& cmp);
+
 public:
     EnumStoreDictionary(IEnumStore& enumStore);
 
     ~EnumStoreDictionary() override;
 
-    const DictionaryT &getDictionary() const { return this->_dict; }
-    DictionaryT &getDictionary() { return this->_dict; }
-
-    uint32_t getNumUniques() const override;
-    void fixupRefCounts(const EnumVector& hist) override;
+    const DictionaryT& get_raw_dictionary() const { return this->_dict; }
 
-    void removeUnusedEnums(const IndexSet& unused,
-                           const datastore::EntryComparator& cmp);
+    void set_ref_counts(const EnumVector& hist) override;
 
-    void freeUnusedEnums(const datastore::EntryComparator& cmp) override;
+    void free_unused_values(const datastore::EntryComparator& cmp) override;
 
-    void freeUnusedEnums(const IndexSet& toRemove,
-                         const datastore::EntryComparator& cmp) override;
+    void free_unused_values(const IndexSet& to_remove,
+                            const datastore::EntryComparator& cmp) override;
 
-    bool findIndex(const datastore::EntryComparator& cmp, Index& idx) const override;
-    bool findFrozenIndex(const datastore::EntryComparator& cmp, Index& idx) const override;
+    bool find_index(const datastore::EntryComparator& cmp, Index& idx) const override;
+    bool find_frozen_index(const datastore::EntryComparator& cmp, Index& idx) const override;
     std::vector<attribute::IAttributeVector::EnumHandle>
-    findMatchingEnums(const datastore::EntryComparator& cmp) const override;
-
-    void onReset() override;
-
-    EnumPostingTree & getPostingDictionary() override;
-    const EnumPostingTree & getPostingDictionary() const override;
+    find_matching_enums(const datastore::EntryComparator& cmp) const override;
 
-    bool hasData() const override;
+    EnumPostingTree& get_posting_dictionary() override;
+    const EnumPostingTree& get_posting_dictionary() const override;
 };
 
 /**
diff --git a/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.cpp b/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.cpp
index f98dbcd5675..0dd7ba426b1 100644
--- a/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.cpp
@@ -28,7 +28,7 @@ EnumeratedLoader::EnumeratedLoader(IEnumStore& store)
 void
 EnumeratedLoader::set_ref_counts()
 {
-    _store.fixupRefCounts(_enums_histogram);
+    _store.set_ref_counts(_enums_histogram);
 }
 
 EnumeratedPostingsLoader::EnumeratedPostingsLoader(IEnumStore& store)
@@ -38,21 +38,21 @@ EnumeratedPostingsLoader::EnumeratedPostingsLoader(IEnumStore& store)
 }
 
 bool
-EnumeratedPostingsLoader::is_folded_change(const Index& lhs, const Index& rhs) const
+EnumeratedPostingsLoader::is_folded_change(Index lhs, Index rhs) const
 {
-    return _store.foldedChange(lhs, rhs);
+    return _store.is_folded_change(lhs, rhs);
 }
 
 void
 EnumeratedPostingsLoader::set_ref_count(Index idx, uint32_t ref_count)
 {
-    _store.fixupRefCount(idx, ref_count);
+    _store.set_ref_count(idx, ref_count);
 }
 
 void
-EnumeratedPostingsLoader::free_unused_enums()
+EnumeratedPostingsLoader::free_unused_values()
 {
-    _store.freeUnusedEnums();
+    _store.free_unused_values();
 }
 
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.h b/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.h
index 71c17a71661..eed97b50552 100644
--- a/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.h
+++ b/searchlib/src/vespa/searchlib/attribute/enum_store_loaders.h
@@ -58,9 +58,9 @@ public:
     void sort_loaded_enums() {
         attribute::sortLoadedByEnum(_loaded_enums);
     }
-    bool is_folded_change(const Index& lhs, const Index& rhs) const;
+    bool is_folded_change(Index lhs, Index rhs) const;
     void set_ref_count(Index idx, uint32_t ref_count);
-    void free_unused_enums();
+    void free_unused_values();
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/enumattribute.h b/searchlib/src/vespa/searchlib/attribute/enumattribute.h
index 8c9c949c504..82a0df6e157 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumattribute.h
@@ -61,7 +61,7 @@ protected:
 
     const IEnumStore* getEnumStoreBase() const override { return &_enumStore; }
     IEnumStore* getEnumStoreBase() override { return &_enumStore; }
-    EnumEntryType getFromEnum(EnumHandle e) const override { return _enumStore.getValue(e); }
+    EnumEntryType getFromEnum(EnumHandle e) const override { return _enumStore.get_value(e); }
 
     void load_posting_lists(LoadedVector& loaded) override { (void) loaded; }
     void load_enum_store(LoadedVector& loaded) override;
@@ -80,7 +80,7 @@ protected:
 public:
     EnumAttribute(const vespalib::string & baseFileName, const AttributeVector::Config & cfg);
     ~EnumAttribute();
-    bool findEnum(EnumEntryType v, EnumHandle & e) const override { return _enumStore.findEnum(v, e); }
+    bool findEnum(EnumEntryType v, EnumHandle & e) const override { return _enumStore.find_enum(v, e); }
 };
 
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp b/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
index 76a9fc91916..897d8a10ec6 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
@@ -56,7 +56,7 @@ template <typename B>
 uint64_t
 EnumAttribute<B>::getUniqueValueCount() const
 {
-    return _enumStore.getNumUniques();
+    return _enumStore.get_num_uniques();
 }
 
 template <typename B>
@@ -80,14 +80,14 @@ template <typename B>
 vespalib::MemoryUsage
 EnumAttribute<B>::getEnumStoreValuesMemoryUsage() const
 {
-    return _enumStore.getValuesMemoryUsage();
+    return _enumStore.get_values_memory_usage();
 }
 
 template <typename B>
 vespalib::AddressSpace
 EnumAttribute<B>::getEnumStoreAddressSpaceUsage() const
 {
-    return _enumStore.getAddressSpaceUsage();
+    return _enumStore.get_address_space_usage();
 }
 
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.h b/searchlib/src/vespa/searchlib/attribute/enumstore.h
index c41794726ac..3c5f43f05ff 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.h
@@ -58,7 +58,7 @@ private:
     EnumStoreT(const EnumStoreT & rhs) = delete;
     EnumStoreT & operator=(const EnumStoreT & rhs) = delete;
 
-    void freeUnusedEnum(Index idx, IndexSet& unused) override;
+    void free_value_if_unused(Index idx, IndexSet &unused) override;
 
     const datastore::UniqueStoreEntryBase& get_entry_base(Index idx) const {
         return _store.get_allocator().get_wrapped(idx);
@@ -75,41 +75,37 @@ public:
     EnumStoreT(bool has_postings);
     virtual ~EnumStoreT();
 
-    uint32_t getRefCount(Index idx) const { return get_entry_base(idx).get_ref_count(); }
-    void incRefCount(Index idx) { return get_entry_base(idx).inc_ref_count(); }
+    uint32_t get_ref_count(Index idx) const { return get_entry_base(idx).get_ref_count(); }
+    void inc_ref_count(Index idx) { return get_entry_base(idx).inc_ref_count(); }
 
     // Only use when reading from enumerated attribute save files
-    // TODO: Instead create an API that is used for loading/initializing.
-    void fixupRefCount(Index idx, uint32_t refCount) override {
-        get_entry_base(idx).set_ref_count(refCount);
+    void set_ref_count(Index idx, uint32_t ref_count) override {
+        get_entry_base(idx).set_ref_count(ref_count);
     }
 
-    uint32_t getNumUniques() const override { return _dict->getNumUniques(); }
+    uint32_t get_num_uniques() const override { return _dict->get_num_uniques(); }
 
-    vespalib::MemoryUsage getValuesMemoryUsage() const override { return _store.get_allocator().get_data_store().getMemoryUsage(); }
-    vespalib::MemoryUsage getDictionaryMemoryUsage() const override { return _dict->get_memory_usage(); }
+    vespalib::MemoryUsage get_values_memory_usage() const override { return _store.get_allocator().get_data_store().getMemoryUsage(); }
+    vespalib::MemoryUsage get_dictionary_memory_usage() const override { return _dict->get_memory_usage(); }
 
-    vespalib::AddressSpace getAddressSpaceUsage() const;
+    vespalib::AddressSpace get_address_space_usage() const;
 
-    void transferHoldLists(generation_t generation);
-    void trimHoldLists(generation_t firstUsed);
+    void transfer_hold_lists(generation_t generation);
+    void trim_hold_lists(generation_t first_used);
 
     ssize_t load_unique_values(const void* src, size_t available, IndexVector& idx) override;
 
-    void fixupRefCounts(const EnumVector &hist) override { _dict->fixupRefCounts(hist); }
-    void freezeTree() { _store.freeze(); }
+    void set_ref_counts(const EnumVector& hist) override { _dict->set_ref_counts(hist); }
+    void freeze_dictionary() { _store.freeze(); }
 
-    IEnumStoreDictionary &getEnumStoreDict() override { return *_dict; }
-    const IEnumStoreDictionary &getEnumStoreDict() const override { return *_dict; }
-    EnumPostingTree &getPostingDictionary() { return _dict->getPostingDictionary(); }
+    IEnumStoreDictionary& get_dictionary() override { return *_dict; }
+    const IEnumStoreDictionary& get_dictionary() const override { return *_dict; }
+    EnumPostingTree& get_posting_dictionary() { return _dict->get_posting_dictionary(); }
+    const EnumPostingTree& get_posting_dictionary() const { return _dict->get_posting_dictionary(); }
 
-    const EnumPostingTree &getPostingDictionary() const {
-        return _dict->getPostingDictionary();
-    }
-
-    bool getValue(Index idx, EntryType& value) const;
-    EntryType getValue(uint32_t idx) const { return getValue(Index(EntryRef(idx))); }
-    EntryType getValue(Index idx) const { return _store.get(idx); }
+    bool get_value(Index idx, EntryType& value) const;
+    EntryType get_value(uint32_t idx) const { return get_value(Index(EntryRef(idx))); }
+    EntryType get_value(Index idx) const { return _store.get(idx); }
 
     /**
      * Helper class used to load an enum store from non-enumerated save files.
@@ -171,7 +167,7 @@ public:
             }
         }
         void commit() {
-            _store.freeUnusedEnums(_possibly_unused);
+            _store.free_unused_values(_possibly_unused);
         }
     };
 
@@ -196,13 +192,13 @@ public:
     }
 
     void write_value(BufferWriter& writer, Index idx) const override;
-    bool foldedChange(const Index &idx1, const Index &idx2) const override;
-    bool findEnum(EntryType value, IEnumStore::EnumHandle &e) const;
-    std::vector<IEnumStore::EnumHandle> findFoldedEnums(EntryType value) const;
+    bool is_folded_change(Index idx1, Index idx2) const override;
+    bool find_enum(EntryType value, IEnumStore::EnumHandle& e) const;
+    std::vector<IEnumStore::EnumHandle> find_folded_enums(EntryType value) const;
     Index insert(EntryType value);
-    bool findIndex(EntryType value, Index &idx) const;
-    void freeUnusedEnums() override;
-    void freeUnusedEnums(const IndexSet& toRemove);
+    bool find_index(EntryType value, Index& idx) const;
+    void free_unused_values() override;
+    void free_unused_values(const IndexSet& to_remove);
     vespalib::MemoryUsage update_stat() override;
     std::unique_ptr<EnumIndexRemapper> consider_compact(const CompactionStrategy& compaction_strategy) override;
     std::unique_ptr<EnumIndexRemapper> compact_worst(bool compact_memory, bool compact_address_space) override;
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.hpp b/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
index 908d25b62e2..e39ecc17aac 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
@@ -23,7 +23,7 @@
 namespace search {
 
 template <typename EntryT>
-void EnumStoreT<EntryT>::freeUnusedEnum(Index idx, IndexSet& unused)
+void EnumStoreT<EntryT>::free_value_if_unused(Index idx, IndexSet& unused)
 {
     const auto& entry = get_entry_base(idx);
     if (entry.get_ref_count() == 0) {
@@ -90,21 +90,21 @@ EnumStoreT<EntryT>::~EnumStoreT() = default;
 
 template <typename EntryT>
 vespalib::AddressSpace
-EnumStoreT<EntryT>::getAddressSpaceUsage() const
+EnumStoreT<EntryT>::get_address_space_usage() const
 {
     return _store.get_address_space_usage();
 }
 
 template <typename EntryT>
 void
-EnumStoreT<EntryT>::transferHoldLists(generation_t generation)
+EnumStoreT<EntryT>::transfer_hold_lists(generation_t generation)
 {
     _store.transferHoldLists(generation);
 }
 
 template <typename EntryT>
 void
-EnumStoreT<EntryT>::trimHoldLists(generation_t firstUsed)
+EnumStoreT<EntryT>::trim_hold_lists(generation_t firstUsed)
 {
     // remove generations in the range [0, firstUsed>
     _store.trimHoldLists(firstUsed);
@@ -123,7 +123,7 @@ EnumStoreT<EntryT>::load_unique_values(const void* src, size_t available, IndexV
 
 template <typename EntryT>
 bool
-EnumStoreT<EntryT>::getValue(Index idx, EntryT& value) const
+EnumStoreT<EntryT>::get_value(Index idx, EntryT& value) const
 {
     if (!idx.valid()) {
         return false;
@@ -156,7 +156,7 @@ EnumStoreT<EntryT>::write_value(BufferWriter& writer, Index idx) const
 
 template <class EntryT>
 bool
-EnumStoreT<EntryT>::foldedChange(const Index &idx1, const Index &idx2) const
+EnumStoreT<EntryT>::is_folded_change(Index idx1, Index idx2) const
 {
     auto cmp = make_folded_comparator();
     assert(!cmp(idx2, idx1));
@@ -165,11 +165,11 @@ EnumStoreT<EntryT>::foldedChange(const Index &idx1, const Index &idx2) const
 
 template <typename EntryT>
 bool
-EnumStoreT<EntryT>::findEnum(EntryType value, IEnumStore::EnumHandle &e) const
+EnumStoreT<EntryT>::find_enum(EntryType value, IEnumStore::EnumHandle& e) const
 {
     auto cmp = make_comparator(value);
     Index idx;
-    if (_dict->findFrozenIndex(cmp, idx)) {
+    if (_dict->find_frozen_index(cmp, idx)) {
         e = idx.ref();
         return true;
     }
@@ -178,34 +178,34 @@ EnumStoreT<EntryT>::findEnum(EntryType value, IEnumStore::EnumHandle &e) const
 
 template <typename EntryT>
 std::vector<IEnumStore::EnumHandle>
-EnumStoreT<EntryT>::findFoldedEnums(EntryType value) const
+EnumStoreT<EntryT>::find_folded_enums(EntryType value) const
 {
     auto cmp = make_folded_comparator(value);
-    return _dict->findMatchingEnums(cmp);
+    return _dict->find_matching_enums(cmp);
 }
 
 template <typename EntryT>
 bool
-EnumStoreT<EntryT>::findIndex(EntryType value, Index &idx) const
+EnumStoreT<EntryT>::find_index(EntryType value, Index& idx) const
 {
     auto cmp = make_comparator(value);
-    return _dict->findIndex(cmp, idx);
+    return _dict->find_index(cmp, idx);
 }
 
 template <typename EntryT>
 void
-EnumStoreT<EntryT>::freeUnusedEnums()
+EnumStoreT<EntryT>::free_unused_values()
 {
     auto cmp = make_comparator();
-    _dict->freeUnusedEnums(cmp);
+    _dict->free_unused_values(cmp);
 }
 
 template <typename EntryT>
 void
-EnumStoreT<EntryT>::freeUnusedEnums(const IndexSet& toRemove)
+EnumStoreT<EntryT>::free_unused_values(const IndexSet& to_remove)
 {
     auto cmp = make_comparator();
-    _dict->freeUnusedEnums(toRemove, cmp);
+    _dict->free_unused_values(to_remove, cmp);
 }
 
 template <typename EntryT>
diff --git a/searchlib/src/vespa/searchlib/attribute/i_enum_store.h b/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
index a5a888f10e7..93d5d79e670 100644
--- a/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
+++ b/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
@@ -54,16 +54,16 @@ public:
 
     virtual void write_value(BufferWriter& writer, Index idx) const = 0;
     virtual ssize_t load_unique_values(const void* src, size_t available, IndexVector& idx) = 0;
-    virtual void fixupRefCount(Index idx, uint32_t refCount) = 0;
-    virtual void fixupRefCounts(const EnumVector& histogram) = 0;
-    virtual void freeUnusedEnum(Index idx, IndexSet& unused) = 0;
-    virtual void freeUnusedEnums() = 0;
-    virtual bool foldedChange(const Index& idx1, const Index& idx2) const = 0;
-    virtual IEnumStoreDictionary& getEnumStoreDict() = 0;
-    virtual const IEnumStoreDictionary& getEnumStoreDict() const = 0;
-    virtual uint32_t getNumUniques() const = 0;
-    virtual vespalib::MemoryUsage getValuesMemoryUsage() const = 0;
-    virtual vespalib::MemoryUsage getDictionaryMemoryUsage() const = 0;
+    virtual void set_ref_count(Index idx, uint32_t ref_count) = 0;
+    virtual void set_ref_counts(const EnumVector& histogram) = 0;
+    virtual void free_value_if_unused(Index idx, IndexSet& unused) = 0;
+    virtual void free_unused_values() = 0;
+    virtual bool is_folded_change(Index idx1, Index idx2) const = 0;
+    virtual IEnumStoreDictionary& get_dictionary() = 0;
+    virtual const IEnumStoreDictionary& get_dictionary() const = 0;
+    virtual uint32_t get_num_uniques() const = 0;
+    virtual vespalib::MemoryUsage get_values_memory_usage() const = 0;
+    virtual vespalib::MemoryUsage get_dictionary_memory_usage() const = 0;
     virtual vespalib::MemoryUsage update_stat() = 0;
     virtual std::unique_ptr<EnumIndexRemapper> consider_compact(const CompactionStrategy& compaction_strategy) = 0;
     virtual std::unique_ptr<EnumIndexRemapper> compact_worst(bool compact_memory, bool compact_address_space) = 0;
@@ -82,7 +82,7 @@ public:
     virtual std::unique_ptr<Enumerator> make_enumerator() const = 0;
 
     template <typename TreeT>
-    void fixupRefCounts(const EnumVector& hist, TreeT& tree) {
+    void set_ref_counts(const EnumVector& hist, TreeT& tree) {
         if (hist.empty()) {
             return;
         }
@@ -91,10 +91,10 @@ public:
 
         for (HistIT hi(hist.begin()), hie(hist.end()); hi != hie; ++hi, ++ti) {
             assert(ti.valid());
-            fixupRefCount(ti.getKey(), *hi);
+            set_ref_count(ti.getKey(), *hi);
         }
         assert(!ti.valid());
-        freeUnusedEnums();
+        free_unused_values();
     }
 };
 
diff --git a/searchlib/src/vespa/searchlib/attribute/i_enum_store_dictionary.h b/searchlib/src/vespa/searchlib/attribute/i_enum_store_dictionary.h
index 15b351b7b33..a7784036a54 100644
--- a/searchlib/src/vespa/searchlib/attribute/i_enum_store_dictionary.h
+++ b/searchlib/src/vespa/searchlib/attribute/i_enum_store_dictionary.h
@@ -37,22 +37,17 @@ public:
 public:
     virtual ~IEnumStoreDictionary() = default;
 
-    virtual uint32_t getNumUniques() const = 0;
-
-    virtual void fixupRefCounts(const EnumVector& hist) = 0;
-    virtual void freeUnusedEnums(const datastore::EntryComparator& cmp) = 0;
-    virtual void freeUnusedEnums(const IndexSet& toRemove,
-                                 const datastore::EntryComparator& cmp) = 0;
-    virtual bool findIndex(const datastore::EntryComparator& cmp, Index& idx) const = 0;
-    virtual bool findFrozenIndex(const datastore::EntryComparator& cmp, Index& idx) const = 0;
+    virtual void set_ref_counts(const EnumVector& hist) = 0;
+    virtual void free_unused_values(const datastore::EntryComparator& cmp) = 0;
+    virtual void free_unused_values(const IndexSet& to_remove,
+                                    const datastore::EntryComparator& cmp) = 0;
+    virtual bool find_index(const datastore::EntryComparator& cmp, Index& idx) const = 0;
+    virtual bool find_frozen_index(const datastore::EntryComparator& cmp, Index& idx) const = 0;
     virtual std::vector<attribute::IAttributeVector::EnumHandle>
-    findMatchingEnums(const datastore::EntryComparator& cmp) const = 0;
+    find_matching_enums(const datastore::EntryComparator& cmp) const = 0;
 
-    virtual void onReset() = 0;
-
-    virtual EnumPostingTree& getPostingDictionary() = 0;
-    virtual const EnumPostingTree& getPostingDictionary() const = 0;
-    virtual bool hasData() const = 0;
+    virtual EnumPostingTree& get_posting_dictionary() = 0;
+    virtual const EnumPostingTree& get_posting_dictionary() const = 0;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/multienumattribute.h b/searchlib/src/vespa/searchlib/attribute/multienumattribute.h
index c80178e1307..fb16005c300 100644
--- a/searchlib/src/vespa/searchlib/attribute/multienumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/multienumattribute.h
@@ -71,7 +71,7 @@ protected:
     virtual void applyValueChanges(const DocIndices& docIndices, EnumStoreBatchUpdater& updater);
 
     virtual void freezeEnumDictionary() {
-        this->getEnumStore().freezeTree();
+        this->getEnumStore().freeze_dictionary();
     }
 
     void fillValues(LoadedVector & loaded) override;
diff --git a/searchlib/src/vespa/searchlib/attribute/multienumattribute.hpp b/searchlib/src/vespa/searchlib/attribute/multienumattribute.hpp
index 3a96c9be42f..219b3dd2473 100644
--- a/searchlib/src/vespa/searchlib/attribute/multienumattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multienumattribute.hpp
@@ -25,7 +25,7 @@ bool
 MultiValueEnumAttribute<B, M>::extractChangeData(const Change & c, EnumIndex & idx)
 {
     if (c._enumScratchPad == Change::UNSET_ENUM) {
-        return this->_enumStore.findIndex(c._data.raw(), idx);
+        return this->_enumStore.find_index(c._data.raw(), idx);
     }
     idx = EnumIndex(datastore::EntryRef(c._enumScratchPad));
     return true;
@@ -40,7 +40,7 @@ MultiValueEnumAttribute<B, M>::considerAttributeChange(const Change & c, UniqueS
          (c._type >= ChangeBase::INCREASEWEIGHT && c._type <= ChangeBase::DIVWEIGHT)))
     {
         EnumIndex idx;
-        if (!this->_enumStore.findIndex(c._data.raw(), idx)) {
+        if (!this->_enumStore.find_index(c._data.raw(), idx)) {
             newUniques.insert(c._data);
         } else {
             c._enumScratchPad = idx.ref();
@@ -191,7 +191,7 @@ MultiValueEnumAttribute<B, M>::onUpdateStat()
     total.merge(this->_mvMapping.updateStat());
     total.merge(this->getChangeVectorMemoryUsage());
     mergeMemoryStats(total);
-    this->updateStatistics(this->_mvMapping.getTotalValueCnt(), this->_enumStore.getNumUniques(), total.allocatedBytes(),
+    this->updateStatistics(this->_mvMapping.getTotalValueCnt(), this->_enumStore.get_num_uniques(), total.allocatedBytes(),
                      total.usedBytes(), total.deadBytes(), total.allocatedBytesOnHold());
 }
 
@@ -199,7 +199,7 @@ template <typename B, typename M>
 void
 MultiValueEnumAttribute<B, M>::removeOldGenerations(generation_t firstUsed)
 {
-    this->_enumStore.trimHoldLists(firstUsed);
+    this->_enumStore.trim_hold_lists(firstUsed);
     this->_mvMapping.trimHoldLists(firstUsed);
 }
 
@@ -215,7 +215,7 @@ MultiValueEnumAttribute<B, M>::onGenerationChange(generation_t generation)
      */
     freezeEnumDictionary();
     this->_mvMapping.transferHoldLists(generation - 1);
-    this->_enumStore.transferHoldLists(generation - 1);
+    this->_enumStore.transfer_hold_lists(generation - 1);
 }
 
 template <typename B, typename M>
diff --git a/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h b/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
index 75453268120..5c3d2e37657 100644
--- a/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
@@ -67,7 +67,7 @@ protected:
         {
             WeightedIndexArrayRef indices(_toBeSearched._mvMapping.get(doc));
             for (uint32_t i(elemId); i < indices.size(); i++) {
-                T v = _toBeSearched._enumStore.getValue(indices[i].value());
+                T v = _toBeSearched._enumStore.get_value(indices[i].value());
                 if (this->match(v)) {
                     weight = indices[i].weight();
                     return i;
@@ -81,7 +81,7 @@ protected:
         {
             WeightedIndexArrayRef indices(_toBeSearched._mvMapping.get(doc));
             for (uint32_t i(elemId); i < indices.size(); i++) {
-                T v = _toBeSearched._enumStore.getValue(indices[i].value());
+                T v = _toBeSearched._enumStore.get_value(indices[i].value());
                 if (this->match(v)) {
                     return i;
                 }
@@ -121,7 +121,7 @@ protected:
         {
             WeightedIndexArrayRef indices(_toBeSearched._mvMapping.get(doc));
             for (uint32_t i(elemId); i < indices.size(); i++) {
-                T v = _toBeSearched._enumStore.getValue(indices[i].value());
+                T v = _toBeSearched._enumStore.get_value(indices[i].value());
                 if (this->match(v)) {
                     weight = 1;
                     return i;
@@ -137,7 +137,7 @@ protected:
         {
             WeightedIndexArrayRef indices(_toBeSearched._mvMapping.get(doc));
             for (uint32_t i(elemId); i < indices.size(); i++) {
-                T v = _toBeSearched._enumStore.getValue(indices[i].value());
+                T v = _toBeSearched._enumStore.get_value(indices[i].value());
                 if (this->match(v)) {
                     return i;
                 }
@@ -169,7 +169,7 @@ public:
         if (indices.size() == 0) {
             return T();
         } else {
-            return this->_enumStore.getValue(indices[0].value());
+            return this->_enumStore.get_value(indices[0].value());
         }
     }
     largeint_t getInt(DocId doc) const override {
@@ -184,7 +184,7 @@ public:
         WeightedIndexArrayRef indices(this->_mvMapping.get(doc));
         uint32_t valueCount = indices.size();
         for(uint32_t i = 0, m = std::min(sz, valueCount); i < m; i++) {
-            buffer[i] = static_cast<BufferType>(this->_enumStore.getValue(indices[i].value()));
+            buffer[i] = static_cast<BufferType>(this->_enumStore.get_value(indices[i].value()));
         }
         return valueCount;
     }
@@ -203,7 +203,7 @@ public:
         WeightedIndexArrayRef indices(this->_mvMapping.get(doc));
         uint32_t valueCount = indices.size();
         for (uint32_t i = 0, m = std::min(sz, valueCount); i < m; ++i) {
-            buffer[i] = WeightedType(static_cast<ValueType>(this->_enumStore.getValue(indices[i].value())), indices[i].weight());
+            buffer[i] = WeightedType(static_cast<ValueType>(this->_enumStore.get_value(indices[i].value())), indices[i].weight());
         }
         return valueCount;
     }
diff --git a/searchlib/src/vespa/searchlib/attribute/multinumericpostattribute.hpp b/searchlib/src/vespa/searchlib/attribute/multinumericpostattribute.hpp
index 7a8a2ff132a..15d5d9e615a 100644
--- a/searchlib/src/vespa/searchlib/attribute/multinumericpostattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multinumericpostattribute.hpp
@@ -10,7 +10,7 @@ template <typename B, typename M>
 void
 MultiValueNumericPostingAttribute<B, M>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 template <typename B, typename M>
@@ -86,7 +86,7 @@ template <typename B, typename M>
 IDocumentWeightAttribute::LookupResult
 MultiValueNumericPostingAttribute<B, M>::DocumentWeightAttributeAdapter::lookup(const vespalib::string &term) const
 {
-    const Dictionary &dictionary = self._enumStore.getPostingDictionary();
+    const Dictionary &dictionary = self._enumStore.get_posting_dictionary();
     const FrozenDictionary frozenDictionary(dictionary.getFrozenView());
     DictionaryConstIterator dictItr(btree::BTreeNode::Ref(), dictionary.getAllocator());
 
diff --git a/searchlib/src/vespa/searchlib/attribute/multistringattribute.h b/searchlib/src/vespa/searchlib/attribute/multistringattribute.h
index c117aeea6b9..781fe106d87 100644
--- a/searchlib/src/vespa/searchlib/attribute/multistringattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/multistringattribute.h
@@ -67,23 +67,23 @@ public:
         if (indices.size() == 0) {
             return NULL;
         } else {
-            return this->_enumStore.getValue(indices[0].value());
+            return this->_enumStore.get_value(indices[0].value());
         }
     }
 
     std::vector<EnumHandle> findFoldedEnums(const char *value) const override {
-        return this->_enumStore.findFoldedEnums(value);
+        return this->_enumStore.find_folded_enums(value);
     }
 
     const char * getStringFromEnum(EnumHandle e) const override {
-        return this->_enumStore.getValue(e);
+        return this->_enumStore.get_value(e);
     }
     template <typename BufferType>
     uint32_t getHelper(DocId doc, BufferType * buffer, uint32_t sz) const {
         WeightedIndexArrayRef indices(this->_mvMapping.get(doc));
         uint32_t valueCount = indices.size();
         for(uint32_t i = 0, m = std::min(sz, valueCount); i < m; i++) {
-            buffer[i] = this->_enumStore.getValue(indices[i].value());
+            buffer[i] = this->_enumStore.get_value(indices[i].value());
         }
         return valueCount;
     }
@@ -100,7 +100,7 @@ public:
         WeightedIndexArrayRef indices(this->_mvMapping.get(doc));
         uint32_t valueCount = indices.size();
         for (uint32_t i = 0, m = std::min(sz, valueCount); i < m; ++i) {
-            buffer[i] = WeightedType(this->_enumStore.getValue(indices[i].value()), indices[i].weight());
+            buffer[i] = WeightedType(this->_enumStore.get_value(indices[i].value()), indices[i].weight());
         }
         return valueCount;
     }
diff --git a/searchlib/src/vespa/searchlib/attribute/multistringattribute.hpp b/searchlib/src/vespa/searchlib/attribute/multistringattribute.hpp
index a435c94d8f6..cc599c18800 100644
--- a/searchlib/src/vespa/searchlib/attribute/multistringattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multistringattribute.hpp
@@ -32,7 +32,7 @@ template <typename B, typename M>
 void
 MultiValueStringAttributeT<B, M>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 
@@ -54,7 +54,7 @@ template <typename E>
 class EnumAccessor {
 public:
     EnumAccessor(const E & enumStore) : _enumStore(enumStore) { }
-    const char * get(typename E::Index index) const { return _enumStore.getValue(index); }
+    const char * get(typename E::Index index) const { return _enumStore.get_value(index); }
 private:
     const E & _enumStore;
 };
@@ -97,7 +97,7 @@ MultiValueStringAttributeT<B, M>::StringImplSearchContext::onFind(DocId doc, int
     const auto& attr = static_cast<const MultiValueStringAttributeT<B, M>&>(attribute());
     WeightedIndexArrayRef indices(attr._mvMapping.get(doc));
     for (uint32_t i(elemId); i < indices.size(); i++) {
-        if (isMatch(attr._enumStore.getValue(indices[i].value()))) {
+        if (isMatch(attr._enumStore.get_value(indices[i].value()))) {
             return i;
         }
     }
@@ -110,7 +110,7 @@ template <typename BT>
 MultiValueStringAttributeT<B, M>::StringTemplSearchContext<BT>::
 StringTemplSearchContext(QueryTermSimpleUP qTerm, const AttrType & toBeSearched) :
     BT(std::move(qTerm), toBeSearched),
-    EnumHintSearchContext(toBeSearched.getEnumStore().getEnumStoreDict(),
+    EnumHintSearchContext(toBeSearched.getEnumStore().get_dictionary(),
                           toBeSearched.getCommittedDocIdLimit(),
                           toBeSearched.getStatus().getNumValues())
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/multistringpostattribute.hpp b/searchlib/src/vespa/searchlib/attribute/multistringpostattribute.hpp
index 297261877d9..7365f79cb00 100644
--- a/searchlib/src/vespa/searchlib/attribute/multistringpostattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multistringpostattribute.hpp
@@ -43,7 +43,7 @@ applyValueChanges(const DocIndices& docIndices, EnumStoreBatchUpdater &updater)
 {
     using PostingChangeComputer = PostingChangeComputerT<WeightedIndex, PostingMap>;
     EnumStore &enumStore(this->getEnumStore());
-    Dictionary &dict(enumStore.getPostingDictionary());
+    Dictionary &dict(enumStore.get_posting_dictionary());
     auto compare = enumStore.make_folded_comparator();
 
     StringEnumIndexMapper mapper(dict);
@@ -56,7 +56,7 @@ template <typename B, typename T>
 void
 MultiValueStringPostingAttributeT<B, T>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 template <typename B, typename T>
@@ -102,7 +102,7 @@ template <typename B, typename T>
 IDocumentWeightAttribute::LookupResult
 MultiValueStringPostingAttributeT<B, T>::DocumentWeightAttributeAdapter::lookup(const vespalib::string &term) const
 {
-    const Dictionary &dictionary = self._enumStore.getPostingDictionary();
+    const Dictionary &dictionary = self._enumStore.get_posting_dictionary();
     const FrozenDictionary frozenDictionary(dictionary.getFrozenView());
     DictionaryConstIterator dictItr(btree::BTreeNode::Ref(), dictionary.getAllocator());
     auto comp = self._enumStore.make_folded_comparator(term.c_str());
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp b/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
index 879706dc09d..21bbec729df 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
@@ -14,10 +14,10 @@ PostingListAttributeBase<P>::
 PostingListAttributeBase(AttributeVector &attr,
                          IEnumStore &enumStore)
     : attribute::IPostingListAttributeBase(),
-      _postingList(enumStore.getEnumStoreDict().getPostingDictionary(), attr.getStatus(),
+      _postingList(enumStore.get_dictionary().get_posting_dictionary(), attr.getStatus(),
                    attr.getConfig()),
       _attr(attr),
-      _dict(enumStore.getEnumStoreDict().getPostingDictionary()),
+      _dict(enumStore.get_dictionary().get_posting_dictionary()),
       _esb(enumStore)
 { }
 
@@ -108,7 +108,7 @@ PostingListAttributeBase<P>::handle_load_posting_lists_and_update_enum_store(enu
                        &postings._removals[0],
                        &postings._removals[0] + postings._removals.size());
     posting_itr.writeData(newIndex.ref());
-    loader.free_unused_enums();
+    loader.free_unused_values();
 }
 
 template <typename P>
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
index fdaf338b229..df63963b0af 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
@@ -188,7 +188,7 @@ private:
     using Parent::_enumStore;
     using Parent::getRegex;
     bool useThis(const PostingListSearchContext::DictionaryConstIterator & it) const override {
-        return getRegex() ? getRegex()->match(_enumStore.getValue(it.getKey())) : true;
+        return getRegex() ? getRegex()->match(_enumStore.get_value(it.getKey())) : true;
     }
 public:
     StringPostingSearchContext(QueryTermSimpleUP qTerm, bool useBitVector, const AttrT &toBeSearched);
@@ -249,7 +249,7 @@ template <typename BaseSC, typename BaseSC2, typename AttrT>
 PostingSearchContext<BaseSC, BaseSC2, AttrT>::
 PostingSearchContext(QueryTermSimpleUP qTerm, bool useBitVector, const AttrT &toBeSearched)
     : BaseSC(std::move(qTerm), toBeSearched),
-      BaseSC2(toBeSearched.getEnumStore().getPostingDictionary(),
+      BaseSC2(toBeSearched.getEnumStore().get_posting_dictionary(),
               toBeSearched.getCommittedDocIdLimit(),
               toBeSearched.getStatus().getNumValues(),
               toBeSearched.hasWeightedSetType(),
@@ -347,10 +347,10 @@ getIterators(bool shouldApplyRangeLimit)
     }
 
     if (this->_lowerDictItr != this->_upperDictItr) {
-        _low = _enumStore.getValue(this->_lowerDictItr.getKey());
+        _low = _enumStore.get_value(this->_lowerDictItr.getKey());
         auto last = this->_upperDictItr;
         --last;
-        _high = _enumStore.getValue(last.getKey());
+        _high = _enumStore.get_value(last.getKey());
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
index d879a0afba4..cb3aa1f639f 100644
--- a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
@@ -80,7 +80,7 @@ protected:
     void updateEnumRefCounts(const Change& c, EnumIndex newIdx, EnumIndex oldIdx, EnumStoreBatchUpdater& updater);
 
     virtual void freezeEnumDictionary() {
-        this->getEnumStore().freezeTree();
+        this->getEnumStore().freeze_dictionary();
     }
 
     virtual void mergeMemoryStats(vespalib::MemoryUsage & total) { (void) total; }
diff --git a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.hpp
index c0df9949b92..265116f3bd1 100644
--- a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.hpp
@@ -55,7 +55,7 @@ SingleValueEnumAttribute<B>::addDoc(DocId & doc)
         // even between addDoc and commit().
         if (_enumIndices[0].valid()) {
             _enumIndices[doc] = _enumIndices[0];
-            this->_enumStore.incRefCount(_enumIndices[0]);
+            this->_enumStore.inc_ref_count(_enumIndices[0]);
         }
     }
     this->incNumDocs();
@@ -114,7 +114,7 @@ SingleValueEnumAttribute<B>::onUpdateStat()
     total.merge(this->_enumStore.update_stat());
     total.merge(this->getChangeVectorMemoryUsage());
     mergeMemoryStats(total);
-    this->updateStatistics(_enumIndices.size(), this->_enumStore.getNumUniques(), total.allocatedBytes(),
+    this->updateStatistics(_enumIndices.size(), this->_enumStore.get_num_uniques(), total.allocatedBytes(),
                      total.usedBytes(), total.deadBytes(), total.allocatedBytesOnHold());
 }
 
@@ -123,7 +123,7 @@ void
 SingleValueEnumAttribute<B>::considerUpdateAttributeChange(const Change & c, UniqueSet & newUniques)
 {
     EnumIndex idx;
-    if (!this->_enumStore.findIndex(c._data.raw(), idx)) {
+    if (!this->_enumStore.find_index(c._data.raw(), idx)) {
         newUniques.insert(c._data);
     }
     considerUpdateAttributeChange(c); // for numeric
@@ -149,7 +149,7 @@ SingleValueEnumAttribute<B>::applyUpdateValueChange(const Change& c, EnumStoreBa
 {
     EnumIndex oldIdx = _enumIndices[c._doc];
     EnumIndex newIdx;
-    this->_enumStore.findIndex(c._data.raw(), newIdx);
+    this->_enumStore.find_index(c._data.raw(), newIdx);
     updateEnumRefCounts(c, newIdx, oldIdx, updater);
 }
 
@@ -232,7 +232,7 @@ template <typename B>
 void
 SingleValueEnumAttribute<B>::removeOldGenerations(generation_t firstUsed)
 {
-    this->_enumStore.trimHoldLists(firstUsed);
+    this->_enumStore.trim_hold_lists(firstUsed);
     getGenerationHolder().trimHoldLists(firstUsed);
 }
 
@@ -248,7 +248,7 @@ SingleValueEnumAttribute<B>::onGenerationChange(generation_t generation)
      */
     freezeEnumDictionary();
     getGenerationHolder().transferHoldLists(generation - 1);
-    this->_enumStore.transferHoldLists(generation - 1);
+    this->_enumStore.transfer_hold_lists(generation - 1);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
index dcf71ff9132..46574871af6 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
@@ -73,14 +73,14 @@ protected:
 
         int32_t find(DocId docId, int32_t elemId, int32_t & weight) const {
             if ( elemId != 0) return -1;
-            T v = _toBeSearched._enumStore.getValue(_toBeSearched.getEnumIndex(docId));
+            T v = _toBeSearched._enumStore.get_value(_toBeSearched.getEnumIndex(docId));
             weight = 1;
             return this->match(v) ? 0 : -1;
         }
 
         int32_t find(DocId docId, int32_t elemId) const {
             if ( elemId != 0) return -1;
-            T v = _toBeSearched._enumStore.getValue(_toBeSearched.getEnumIndex(docId));
+            T v = _toBeSearched._enumStore.get_value(_toBeSearched.getEnumIndex(docId));
             return this->match(v) ? 0 : -1;
         }
 
@@ -107,7 +107,7 @@ public:
     // Attribute read API
     //-------------------------------------------------------------------------
     T get(DocId doc) const override {
-        return this->_enumStore.getValue(this->_enumIndices[doc]);
+        return this->_enumStore.get_value(this->_enumIndices[doc]);
     }
     largeint_t getInt(DocId doc) const override {
         return static_cast<largeint_t>(get(doc));
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.hpp
index f296e2d7795..8730d5da71d 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.hpp
@@ -36,7 +36,7 @@ SingleValueNumericEnumAttribute<B>::considerArithmeticAttributeChange(const Chan
     T newValue = this->applyArithmetic(oldValue, c);
 
     EnumIndex idx;
-    if (!this->_enumStore.findIndex(newValue, idx)) {
+    if (!this->_enumStore.find_index(newValue, idx)) {
         newUniques.insert(newValue);
     }
 
@@ -50,7 +50,7 @@ SingleValueNumericEnumAttribute<B>::applyArithmeticValueChange(const Change& c,
     EnumIndex oldIdx = this->_enumIndices[c._doc];
     EnumIndex newIdx;
     T newValue = this->applyArithmetic(get(c._doc), c);
-    this->_enumStore.findIndex(newValue, newIdx);
+    this->_enumStore.find_index(newValue, newIdx);
 
     this->updateEnumRefCounts(c, newIdx, oldIdx, updater);
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericpostattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singlenumericpostattribute.hpp
index 6c377e411b2..ca6b6caba32 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlenumericpostattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/singlenumericpostattribute.hpp
@@ -29,7 +29,7 @@ template <typename B>
 void
 SingleValueNumericPostingAttribute<B>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 template <typename B>
@@ -46,7 +46,7 @@ SingleValueNumericPostingAttribute<B>::applyUpdateValueChange(const Change & c,
                                                               std::map<DocId, EnumIndex> & currEnumIndices)
 {
     EnumIndex newIdx;
-    enumStore.findIndex(c._data.raw(), newIdx);
+    enumStore.find_index(c._data.raw(), newIdx);
     currEnumIndices[c._doc] = newIdx;
 }
 
@@ -78,7 +78,7 @@ void
 SingleValueNumericPostingAttribute<B>::applyValueChanges(EnumStoreBatchUpdater& updater)
 {
     EnumStore & enumStore = this->getEnumStore();
-    Dictionary & dict = enumStore.getPostingDictionary();
+    Dictionary & dict = enumStore.get_posting_dictionary();
     auto cmp = enumStore.make_comparator();
     PostingMap changePost;
 
@@ -99,7 +99,7 @@ SingleValueNumericPostingAttribute<B>::applyValueChanges(EnumStoreBatchUpdater&
                                    currEnumIndices);
         } else if (change._type >= ChangeBase::ADD && change._type <= ChangeBase::DIV) {
             if (oldIdx.valid()) {
-                T oldValue = enumStore.getValue(oldIdx);
+                T oldValue = enumStore.get_value(oldIdx);
                 T newValue = this->applyArithmetic(oldValue, change);
 
                 auto addItr = dict.find(EnumIndex(), enumStore.make_comparator(newValue));
diff --git a/searchlib/src/vespa/searchlib/attribute/singlestringattribute.h b/searchlib/src/vespa/searchlib/attribute/singlestringattribute.h
index 862b8c86498..5d0c636dc91 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlestringattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singlestringattribute.h
@@ -48,13 +48,13 @@ public:
     //-------------------------------------------------------------------------
     bool isUndefined(DocId doc) const override { return get(doc)[0] == '\0'; }
     const char * get(DocId doc) const override {
-        return this->_enumStore.getValue(this->_enumIndices[doc]);
+        return this->_enumStore.get_value(this->_enumIndices[doc]);
     }
     std::vector<EnumHandle> findFoldedEnums(const char *value) const override {
-        return this->_enumStore.findFoldedEnums(value);
+        return this->_enumStore.find_folded_enums(value);
     }
     const char * getStringFromEnum(EnumHandle e) const override {
-        return this->_enumStore.getValue(e);
+        return this->_enumStore.get_value(e);
     }
     uint32_t get(DocId doc, vespalib::string * v, uint32_t sz) const override {
         if (sz > 0) {
@@ -98,7 +98,7 @@ public:
         int32_t onFind(DocId doc, int32_t elemId) const override {
             if ( elemId != 0) return -1;
             const SingleValueStringAttributeT<B> & attr(static_cast<const SingleValueStringAttributeT<B> &>(attribute()));
-            return isMatch(attr._enumStore.getValue(attr._enumIndices[doc])) ? 0 : -1;
+            return isMatch(attr._enumStore.get_value(attr._enumIndices[doc])) ? 0 : -1;
         }
 
     };
diff --git a/searchlib/src/vespa/searchlib/attribute/singlestringattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singlestringattribute.hpp
index ba9ea24df69..b8535e62c3d 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlestringattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/singlestringattribute.hpp
@@ -31,7 +31,7 @@ template <typename B>
 void
 SingleValueStringAttributeT<B>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 
@@ -46,7 +46,7 @@ SingleValueStringAttributeT<B>::getSearch(QueryTermSimpleUP qTerm,
 template <typename B>
 SingleValueStringAttributeT<B>::StringTemplSearchContext::StringTemplSearchContext(QueryTermSimple::UP qTerm, const AttrType & toBeSearched) :
     StringSingleImplSearchContext(std::move(qTerm), toBeSearched),
-    EnumHintSearchContext(toBeSearched.getEnumStore().getEnumStoreDict(),
+    EnumHintSearchContext(toBeSearched.getEnumStore().get_dictionary(),
                           toBeSearched.getCommittedDocIdLimit(),
                           toBeSearched.getStatus().getNumValues())
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/singlestringpostattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singlestringpostattribute.hpp
index 9639b05931c..38c5b1be0b6 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlestringpostattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/singlestringpostattribute.hpp
@@ -26,7 +26,7 @@ template <typename B>
 void
 SingleValueStringPostingAttributeT<B>::freezeEnumDictionary()
 {
-    this->getEnumStore().freezeTree();
+    this->getEnumStore().freeze_dictionary();
 }
 
 template <typename B>
@@ -43,7 +43,7 @@ SingleValueStringPostingAttributeT<B>::applyUpdateValueChange(const Change & c,
                                                               std::map<DocId, EnumIndex> &currEnumIndices)
 {
     EnumIndex newIdx;
-    enumStore.findIndex(c._data.raw(), newIdx);
+    enumStore.find_index(c._data.raw(), newIdx);
 
     currEnumIndices[c._doc] = newIdx;
 }
@@ -78,7 +78,7 @@ void
 SingleValueStringPostingAttributeT<B>::applyValueChanges(EnumStoreBatchUpdater& updater)
 {
     EnumStore & enumStore = this->getEnumStore();
-    Dictionary & dict = enumStore.getPostingDictionary();
+    Dictionary & dict = enumStore.get_posting_dictionary();
     auto cmp = enumStore.make_folded_comparator();
     PostingMap changePost;