refactor: use C++20 std::ranges for more readable iterator functions …

…(new clang-tidy check)

src/silo/common/data_version.cpp

@@ -20,7 +20,7 @@ DataVersion::Timestamp::Timestamp(std::string value)
 std::optional<DataVersion::Timestamp> DataVersion::Timestamp::fromString(
    std::string timestamp_string
 ) {
-   if (!std::all_of(timestamp_string.begin(), timestamp_string.end(), [](char character) {
+   if (!std::ranges::all_of(timestamp_string, [](char character) {
           return character >= '0' && character <= '9';
        })) {
       return std::nullopt;

src/silo/common/string_utils.cpp

@@ -28,7 +28,7 @@ std::vector<std::string> splitBy(const std::string& value, const std::string_vie
 
 std::string removeSymbol(const std::string& value, char symbol) {
    std::string result = value;
-   result.erase(std::remove(result.begin(), result.end(), symbol), result.end());
+   std::erase(result, symbol);
    return result;
 }
 

src/silo/config/database_config.cpp

@@ -191,11 +191,9 @@ ColumnType DatabaseMetadata::getColumnType() const {
 }
 
 std::optional<DatabaseMetadata> DatabaseConfig::getMetadata(const std::string& name) const {
-   auto element = std::find_if(
-      std::begin(schema.metadata),
-      std::end(schema.metadata),
-      [&name](const auto& metadata) { return metadata.name == name; }
-   );
+   auto element = std::ranges::find_if(schema.metadata, [&name](const auto& metadata) {
+      return metadata.name == name;
+   });
    if (element == std::end(schema.metadata)) {
       return std::nullopt;
    }

src/silo/preprocessing/metadata_info.cpp

@@ -59,7 +59,7 @@ void MetadataInfo::validateMetadataFile(
    std::set<std::string> actual_fields;
    for (size_t idx = 0; idx < result->ColumnCount(); idx++) {
       actual_fields.emplace(result->ColumnName(idx));
-      if (std::find_if(database_config.schema.metadata.begin(), database_config.schema.metadata.end(), [&](const auto& metadata) {
+      if (std::ranges::find_if(database_config.schema.metadata, [&](const auto& metadata) {
              return metadata.name == result->ColumnName(idx);
           }) == database_config.schema.metadata.end()) {
          SPDLOG_WARN(
@@ -130,7 +130,7 @@ void MetadataInfo::validateNdjsonFile(
    std::set<std::string> actual_fields;
    for (size_t idx = 0; idx < result->ColumnCount(); idx++) {
       actual_fields.emplace(result->ColumnName(idx));
-      if (std::find_if(database_config.schema.metadata.begin(), database_config.schema.metadata.end(), [&](const auto& metadata) {
+      if (std::ranges::find_if(database_config.schema.metadata, [&](const auto& metadata) {
              return metadata.name == result->ColumnName(idx);
           }) == database_config.schema.metadata.end()) {
          SPDLOG_WARN(

src/silo/preprocessing/metadata_info.test.cpp

@@ -1,5 +1,8 @@
 #include "silo/preprocessing/metadata_info.h"
 
+#include <algorithm>
+#include <ranges>
+
 #include <gtest/gtest.h>
 
 #include "silo/config/util/config_repository.h"
@@ -51,10 +54,10 @@ TEST(MetadataInfo, isValidMedataFileShouldReturnTrueWithValidMetadataFile) {
    };
 
    const auto fields = silo::preprocessing::MetadataInfo::getMetadataFields(valid_config);
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("gisaid_epi_isl")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("pango_lineage")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("date")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("country")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("gisaid_epi_isl")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("pango_lineage")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("date")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("country")") != fields.end());
 }
 
 TEST(MetadataInfo, shouldValidateCorrectNdjsonInputFile) {
@@ -76,8 +79,8 @@ TEST(MetadataInfo, shouldValidateCorrectNdjsonInputFile) {
 
    const auto fields = silo::preprocessing::MetadataInfo::getMetadataFields(valid_config);
 
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("gisaid_epi_isl")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("pango_lineage")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("date")") != fields.end());
-   ASSERT_TRUE(std::find(fields.begin(), fields.end(), R"("country")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("gisaid_epi_isl")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("pango_lineage")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("date")") != fields.end());
+   ASSERT_TRUE(std::ranges::find(fields, R"("country")") != fields.end());
 }

src/silo/query_engine/actions/action.cpp

@@ -63,7 +63,7 @@ void Action::applySort(QueryResult& result) const {
             cmp
          );
       } else {
-         std::sort(result_vector.begin(), result_vector.end(), cmp);
+         std::ranges::sort(result_vector, cmp);
       }
    }
 }

src/silo/query_engine/actions/aggregated.cpp

@@ -78,9 +78,8 @@ void Aggregated::validateOrderByFields(const Database& database) const {
 
    for (const OrderByField& field : order_by_fields) {
       CHECK_SILO_QUERY(
-         field.name == COUNT_FIELD || std::any_of(
-                                         field_metadata.begin(),
-                                         field_metadata.end(),
+         field.name == COUNT_FIELD || std::ranges::any_of(
+                                         field_metadata,
                                          [&](const silo::storage::ColumnMetadata& metadata) {
                                             return metadata.name == field.name;
                                          }

src/silo/query_engine/actions/details.cpp

@@ -47,9 +47,8 @@ void Details::validateOrderByFields(const Database& database) const {
 
    for (const OrderByField& field : order_by_fields) {
       CHECK_SILO_QUERY(
-         std::any_of(
-            field_metadata.begin(),
-            field_metadata.end(),
+         std::ranges::any_of(
+            field_metadata,
             [&](const silo::storage::ColumnMetadata& metadata) {
                return metadata.name == field.name;
             }
@@ -84,18 +83,18 @@ std::vector<actions::Tuple> mergeSortedTuples(
       [&](const std::pair<iterator, iterator>& lhs, const std::pair<iterator, iterator>& rhs) {
          return tuple_comparator(*rhs.first, *lhs.first);
       };
-   std::make_heap(min_heap.begin(), min_heap.end(), heap_cmp);
+   std::ranges::make_heap(min_heap, heap_cmp);
 
    std::vector<actions::Tuple> result;
 
    for (uint32_t counter = 0; counter < to_produce && !min_heap.empty(); counter++) {
-      std::pop_heap(min_heap.begin(), min_heap.end(), heap_cmp);
+      std::ranges::pop_heap(min_heap, heap_cmp);
       auto& current = min_heap.back();
       result.emplace_back(std::move(*current.first++));
       if (current.first == current.second) {
          min_heap.pop_back();
       } else {
-         std::push_heap(min_heap.begin(), min_heap.end(), heap_cmp);
+         std::ranges::push_heap(min_heap, heap_cmp);
       }
    }
 
@@ -126,25 +125,25 @@ std::vector<actions::Tuple> produceSortedTuplesWithLimit(
          }
 
          if (iterator != end) {
-            std::make_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+            std::ranges::make_heap(my_tuples, tuple_comparator);
             Tuple current_tuple = tuple_factory.allocateOne(*iterator);
             if (tuple_comparator(current_tuple, my_tuples.front())) {
-               std::pop_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+               std::ranges::pop_heap(my_tuples, tuple_comparator);
                my_tuples.back() = current_tuple;
-               std::push_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+               std::ranges::push_heap(my_tuples, tuple_comparator);
             }
             iterator++;
             for (; iterator != end; iterator++) {
                tuple_factory.overwrite(current_tuple, *iterator);
                if (tuple_comparator(current_tuple, my_tuples.front())) {
-                  std::pop_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+                  std::ranges::pop_heap(my_tuples, tuple_comparator);
                   my_tuples.back() = current_tuple;
-                  std::push_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+                  std::ranges::push_heap(my_tuples, tuple_comparator);
                }
             }
-            std::sort_heap(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+            std::ranges::sort_heap(my_tuples, tuple_comparator);
          } else {
-            std::sort(my_tuples.begin(), my_tuples.end(), tuple_comparator);
+            std::ranges::sort(my_tuples, tuple_comparator);
          }
       }
    });
@@ -208,10 +207,8 @@ QueryResult Details::executeAndOrder(
    } else {
       tuples = produceAllTuples(tuple_factories, bitmap_filter);
       if (!order_by_fields.empty() || randomize_seed) {
-         std::sort(
-            tuples.begin(),
-            tuples.end(),
-            Tuple::getComparator(field_metadata, order_by_fields, randomize_seed)
+         std::ranges::sort(
+            tuples, Tuple::getComparator(field_metadata, order_by_fields, randomize_seed)
          );
       }
    }

src/silo/query_engine/actions/fasta_aligned.cpp

@@ -38,8 +38,7 @@ void FastaAligned::validateOrderByFields(const Database& database) const {
    for (const OrderByField& field : order_by_fields) {
       CHECK_SILO_QUERY(
          field.name == primary_key_field ||
-            std::find(sequence_names.begin(), sequence_names.end(), field.name) !=
-               std::end(sequence_names),
+            std::ranges::find(sequence_names, field.name) != std::end(sequence_names),
          fmt::format(
             "OrderByField {} is not contained in the result of this operation. "
             "The only fields returned by the FastaAligned action are {} and {}",
@@ -58,9 +57,8 @@ std::string reconstructSequence(
    uint32_t row_id
 ) {
    std::string reconstructed_sequence;
-   std::transform(
-      sequence_store.reference_sequence.begin(),
-      sequence_store.reference_sequence.end(),
+   std::ranges::transform(
+      sequence_store.reference_sequence,
       std::back_inserter(reconstructed_sequence),
       SymbolType::symbolToChar
    );

src/silo/query_engine/actions/insertions.cpp

@@ -43,9 +43,8 @@ void InsertionAggregation<SymbolType>::validateOrderByFields(const Database& /*d
 
    for (const OrderByField& field : order_by_fields) {
       CHECK_SILO_QUERY(
-         std::any_of(
-            result_field_names.begin(),
-            result_field_names.end(),
+         std::ranges::any_of(
+            result_field_names,
             [&](const std::string& result_field) { return result_field == field.name; }
          ),
          fmt::format(
@@ -67,8 +66,7 @@ void validateSequenceNames(
    std::vector<std::string> all_sequence_names = database.getSequenceNames<SymbolType>();
    for (const std::string& sequence_name : sequence_names) {
       CHECK_SILO_QUERY(
-         std::find(all_sequence_names.begin(), all_sequence_names.end(), sequence_name) !=
-            all_sequence_names.end(),
+         std::ranges::find(all_sequence_names, sequence_name) != all_sequence_names.end(),
          "The database does not contain the " + std::string(SymbolType::SYMBOL_NAME) +
             " sequence '" + sequence_name + "'"
       );
@@ -91,7 +89,7 @@ InsertionAggregation<SymbolType>::validateFieldsAndPreFilterBitmaps(
       for (auto& [sequence_name, sequence_store] :
            database_partition.getSequenceStores<SymbolType>()) {
          if (sequence_names.empty() ||
-             std::find(sequence_names.begin(), sequence_names.end(), sequence_name) !=
+             std::ranges::find(sequence_names, sequence_name) !=
                 sequence_names.end()) {
             OperatorResult& filter = bitmap_filter[i];
             const size_t cardinality = filter->cardinality();

src/silo/query_engine/actions/mutations.cpp

@@ -178,9 +178,8 @@ void Mutations<SymbolType>::validateOrderByFields(const Database& /*database*/)
 
    for (const OrderByField& field : order_by_fields) {
       CHECK_SILO_QUERY(
-         std::any_of(
-            result_field_names.begin(),
-            result_field_names.end(),
+         std::ranges::any_of(
+            result_field_names,
             [&](const std::string& result_field) { return result_field == field.name; }
          ),
          fmt::format(

src/silo/query_engine/actions/tuple.cpp

@@ -321,11 +321,9 @@ std::vector<Tuple::ComparatorField> Tuple::getCompareFields(
    tuple_field_comparators.resize(order_by_fields.size());
    size_t offset = 0;
    for (const auto& metadata : columns_metadata) {
-      auto element = std::find_if(
-         order_by_fields.begin(),
-         order_by_fields.end(),
-         [&](const auto& order_by_field) { return metadata.name == order_by_field.name; }
-      );
+      auto element = std::ranges::find_if(order_by_fields, [&](const auto& order_by_field) {
+         return metadata.name == order_by_field.name;
+      });
       if (element != order_by_fields.end()) {
          const size_t index = std::distance(order_by_fields.begin(), element);
          tuple_field_comparators[index] =

src/silo/query_engine/filter_expressions/and.cpp

@@ -35,9 +35,8 @@ And::And(std::vector<std::unique_ptr<Expression>>&& children)
 
 std::string And::toString() const {
    std::vector<std::string> child_strings;
-   std::transform(
-      children.begin(),
-      children.end(),
+   std::ranges::transform(
+      children,
       std::back_inserter(child_strings),
       [&](const std::unique_ptr<Expression>& child) { return child->toString(); }
    );
@@ -51,12 +50,9 @@ void inline appendVectorToVector(
    std::vector<std::unique_ptr<T>>& vec_1,
    std::vector<std::unique_ptr<T>>& vec_2
 ) {
-   std::transform(
-      vec_1.begin(),
-      vec_1.end(),
-      std::back_inserter(vec_2),
-      [&](std::unique_ptr<T>& ele) { return std::move(ele); }
-   );
+   std::ranges::transform(vec_1, std::back_inserter(vec_2), [&](std::unique_ptr<T>& ele) {
+      return std::move(ele);
+   });
 }
 
 void logCompiledChildren(
@@ -65,24 +61,21 @@ void logCompiledChildren(
    std::vector<std::unique_ptr<operators::Predicate>>& predicates
 ) {
    std::vector<std::string> child_operator_strings;
-   std::transform(
-      non_negated_child_operators.begin(),
-      non_negated_child_operators.end(),
+   std::ranges::transform(
+      non_negated_child_operators,
       std::back_inserter(child_operator_strings),
       [&](const std::unique_ptr<operators::Operator>& operator_) { return operator_->toString(); }
    );
-   std::transform(
-      negated_child_operators.begin(),
-      negated_child_operators.end(),
+   std::ranges::transform(
+      negated_child_operators,
       std::back_inserter(child_operator_strings),
       [&](const std::unique_ptr<operators::Operator>& operator_) {
          return "!" + operator_->toString();
       }
    );
    std::vector<std::string> predicate_strings;
-   std::transform(
-      predicates.begin(),
-      predicates.end(),
+   std::ranges::transform(
+      predicates,
       std::back_inserter(predicate_strings),
       [&](const std::unique_ptr<operators::Predicate>& predicate) { return predicate->toString(); }
    );
@@ -105,9 +98,8 @@ std::tuple<OperatorVector, OperatorVector, std::vector<std::unique_ptr<operators
       AmbiguityMode mode
    ) const {
    OperatorVector all_child_operators;
-   std::transform(
-      children.begin(),
-      children.end(),
+   std::ranges::transform(
+      children,
       std::back_inserter(all_child_operators),
       [&](const std::unique_ptr<Expression>& expression) {
          return expression->compile(database, database_partition, mode);

src/silo/query_engine/filter_expressions/has_mutation.cpp

@@ -63,17 +63,16 @@ std::unique_ptr<operators::Operator> HasMutation<SymbolType>::compile(
       std::vector(SymbolType::SYMBOLS.begin(), SymbolType::SYMBOLS.end());
    if (mode == AmbiguityMode::UPPER_BOUND) {
       // We can only be sure, that the symbol did not mutate, if the ref_symbol is at that position
-      symbols.erase(std::remove(symbols.begin(), symbols.end(), ref_symbol), symbols.end());
+      std::erase(symbols, ref_symbol);
    } else {
       // Remove all symbols that could match the searched base
       for (const auto symbol : SymbolType::AMBIGUITY_SYMBOLS.at(ref_symbol)) {
-         symbols.erase(std::remove(symbols.begin(), symbols.end(), symbol), symbols.end());
+         std::erase(symbols, symbol);
       }
    }
    std::vector<std::unique_ptr<filter_expressions::Expression>> symbol_filters;
-   std::transform(
-      symbols.begin(),
-      symbols.end(),
+   std::ranges::transform(
+      symbols,
       std::back_inserter(symbol_filters),
       [&](typename SymbolType::Symbol symbol) {
          return std::make_unique<SymbolEquals<SymbolType>>(