Improve the interface of SortKey (#555)

Add consistent comparison and `starts_with` to get rid of a lot of `.get()` calls.

.github/workflows/cmake.yml

@@ -32,7 +32,7 @@ jobs:
     - uses: actions/checkout@v2
 
     - name: Install dependencies
-      run:  sudo apt-get install -y libicu-dev tzdata gcc-10 libzstd-dev libjemalloc-dev
+      run:  sudo apt update && sudo apt-get install -y libicu-dev tzdata gcc-10 libzstd-dev libjemalloc-dev
     - name: Install boost
       run : sudo add-apt-repository -y ppa:mhier/libboost-latest && sudo apt update && sudo apt install -y libboost1.74-dev
     - name: Install gcc 11

src/index/StringSortComparator.h

@@ -44,20 +44,37 @@ class LocaleManager {
    * Wraps a string that contains unicode collation weights for another string
    * Only needed for making interfaces explicit and less errorProne
    */
+  // TODO<GCC12> As soon as we have constexpr std::string, this class can
+  //  become constexpr.
   class SortKey {
    public:
     SortKey() = default;
-    explicit SortKey(std::string_view contents) : _content(contents) {}
-    [[nodiscard]] const std::string& get() const { return _content; }
-    std::string& get() { return _content; }
+    explicit SortKey(std::string_view sortKey) : _sortKey(sortKey) {}
+    [[nodiscard]] constexpr const std::string& get() const noexcept {
+      return _sortKey;
+    }
+    constexpr std::string& get() noexcept { return _sortKey; }
 
-    // compare according to the byte value
-    [[nodiscard]] int compare(const SortKey& rhs) const {
-      return _content.compare(rhs._content);
+    // Comparison of sort key is done lexicographically on the byte values
+    // of member `_sortKey`
+    [[nodiscard]] int compare(const SortKey& rhs) const noexcept {
+      return _sortKey.compare(rhs._sortKey);
     }
 
+    auto operator<=>(const SortKey&) const = default;
+    bool operator==(const SortKey&) const = default;
+
+    /// Is this sort key a prefix of another sort key. Note: This does not imply
+    /// any guarantees on the relation of the underlying strings.
+    bool starts_with(const SortKey& rhs) const noexcept {
+      return get().starts_with(rhs.get());
+    }
+
+    /// Return the number of bytes in the `SortKey`
+    std::string::size_type size() const noexcept { return get().size(); }
+
    private:
-    std::string _content;
+    std::string _sortKey;
   };
 
   /// Copy constructor

test/StringSortComparatorTest.cpp

@@ -232,11 +232,15 @@ TEST(LocaleManager, PrefixSortKey) {
   // The words vivæ and vivae compare equal on the primary level, but they
   // get different prefixSortKeys for prefix length 4, because "ae" are two
   // codepoints, whereas "æ" is one.
-  auto a = locIgnorePunct.getPrefixSortKey("vivæ", 4).second.get();
-  auto b = locIgnorePunct.getPrefixSortKey("vivae", 4).second.get();
+  auto a = locIgnorePunct.getPrefixSortKey("vivæ", 4).second;
+  auto b = locIgnorePunct.getPrefixSortKey("vivae", 4).second;
 
   ASSERT_GT(a.size(), b.size());
-  ASSERT_TRUE(ad_utility::startsWith(a, b));
+  ASSERT_TRUE(a.starts_with(b));
+  // Also test the defaulted consistent comparison.
+  ASSERT_GT(a, b);
+  ASSERT_EQ(a, a);
+  ASSERT_NE(a, b);
   ASSERT_FALSE(comp("vivæ", "vivae", LocaleManager::Level::PRIMARY));
   ASSERT_FALSE(comp("vivæ", "vivae", LocaleManager::Level::PRIMARY));
 }