Update some concept constraints to be compatible with v3-range's macros

src/engine/CartesianProductJoin.h

@@ -94,10 +94,9 @@ class CartesianProductJoin : public Operation {
   // rows to write at most. `lastTableOffset` is the offset of the last table,
   // to account for cases where the last table does not cover the whole result
   // and so index 0 of a table does not correspond to row 0 of the result.
-  template <typename R>
-  requires(ql::ranges::random_access_range<R>)
-  IdTable writeAllColumns(R idTables, size_t offset, size_t limit,
-                          size_t lastTableOffset = 0) const {
+  CPP_template(typename R)(requires ql::ranges::random_access_range<R>) IdTable
+      writeAllColumns(R idTables, size_t offset, size_t limit,
+                      size_t lastTableOffset = 0) const {
     AD_CORRECTNESS_CHECK(offset >= lastTableOffset);
     IdTable result{getResultWidth(), getExecutionContext()->getAllocator()};
     // TODO<joka921> Find a solution to cheaply handle the case, that only a
@@ -166,11 +165,9 @@ class CartesianProductJoin : public Operation {
   // `lastTableOffset` is the offset of the last table in the range. This is
   // used to handle `IdTable`s yielded by generators where the range of indices
   // they represent do not cover the whole result.
-  template <typename R>
-  requires(ql::ranges::range<R>)
-  Result::Generator produceTablesLazily(LocalVocab mergedVocab, R idTables,
-                                        size_t offset, size_t limit,
-                                        size_t lastTableOffset = 0) const {
+  CPP_template(typename R)(requires ql::ranges::range<R>) Result::Generator
+      produceTablesLazily(LocalVocab mergedVocab, R idTables, size_t offset,
+                          size_t limit, size_t lastTableOffset = 0) const {
     while (limit > 0) {
       uint64_t limitWithChunkSize = std::min(limit, chunkSize_);
       IdTable idTable = writeAllColumns(ql::ranges::ref_view(idTables), offset,

src/engine/LocalVocab.h

@@ -113,8 +113,8 @@ class LocalVocab {
   // to this local vocab. The purpose is to keep all the contained
   // `LocalVocabEntry`s alive as long as this `LocalVocab` is alive. The
   // primary set of this `LocalVocab` remains unchanged.
-  template <typename R>
-  requires(ql::ranges::range<R>) void mergeWith(const R& vocabs) {
+  CPP_template(typename R)(requires ql::ranges::range<R>) void mergeWith(
+      const R& vocabs) {
     using ql::views::filter;
     auto addWordSet = [this](const std::shared_ptr<const Set>& set) {
       bool added = otherWordSets_.insert(set).second;

src/engine/Result.h

@@ -197,10 +197,11 @@ class Result {
                                                      const Result& result2);
 
   // Overload for more than two `Results`
-  template <typename R>
-  requires(ql::ranges::forward_range<R> &&
-           std::convertible_to<ql::ranges::range_value_t<R>, const Result&>)
-  static SharedLocalVocabWrapper getMergedLocalVocab(R&& subResults) {
+  CPP_template(typename R)(
+      requires ql::ranges::forward_range<R> CPP_and
+          std::convertible_to<ql::ranges::range_value_t<R>,
+                              const Result&>) static SharedLocalVocabWrapper
+      getMergedLocalVocab(R&& subResults) {
     std::vector<const LocalVocab*> vocabs;
     for (const Result& table : subResults) {
       vocabs.push_back(&table.localVocab());

src/engine/TransitivePathImpl.h

@@ -248,11 +248,9 @@ class TransitivePathImpl : public TransitivePathBase {
    * LocalVocab is a no-op).
    * @return Map Maps each Id to its connected Ids in the transitive hull
    */
-  template <typename Node>
-  requires(ql::ranges::range<Node>)
-  NodeGenerator transitiveHull(const T& edges, LocalVocab edgesVocab,
-                               Node startNodes, std::optional<Id> target,
-                               bool yieldOnce) const {
+  CPP_template(typename Node)(requires ql::ranges::range<Node>) NodeGenerator
+      transitiveHull(const T& edges, LocalVocab edgesVocab, Node startNodes,
+                     std::optional<Id> target, bool yieldOnce) const {
     ad_utility::Timer timer{ad_utility::Timer::Stopped};
     for (auto&& tableColumn : startNodes) {
       timer.cont();

src/engine/idTable/IdTable.h

@@ -204,9 +204,8 @@ class IdTable {
   // fails. Additional columns (if `columns.size() > numColumns`) are deleted.
   // This behavior is useful for unit tests Where we can just generically pass
   // in more columns than are needed in any test.
-  template <typename ColT>
-  requires(ql::ranges::forward_range<ColT>)
-  IdTable(size_t numColumns, ColT columns) requires(!isView)
+  CPP_template(typename ColT)(requires ql::ranges::forward_range<ColT>)
+      IdTable(size_t numColumns, ColT columns) requires(!isView)
       : data_{std::make_move_iterator(columns.begin()),
               std::make_move_iterator(columns.end())},
         numColumns_{numColumns} {
@@ -432,10 +431,11 @@ class IdTable {
   // otherwise the behavior is undefined (in Release mode) or an assertion will
   // fail (in Debug mode). The `newRow` can be any random access range that
   // stores the right type and has the right size.
-  template <typename RowLike>
-  requires(ql::ranges::random_access_range<RowLike> &&
-           std::same_as<ql::ranges::range_value_t<RowLike>, T>)
-  void push_back(const RowLike& newRow) requires(!isView) {
+  CPP_template(typename RowLike)(
+      requires ql::ranges::random_access_range<RowLike> CPP_and
+          std::same_as<ql::ranges::range_value_t<RowLike>,
+                       T>) void push_back(const RowLike& newRow)
+      requires(!isView) {
     AD_EXPENSIVE_CHECK(newRow.size() == numColumns());
     ++numRows_;
     ql::ranges::for_each(ad_utility::integerRange(numColumns()),

src/engine/sparqlExpressions/SparqlExpressionGenerators.h

@@ -50,9 +50,9 @@ cppcoro::generator<const std::decay_t<std::invoke_result_t<Transformation, T>>>
   }
 }
 
-template <typename T, typename Transformation = std::identity>
-requires(ql::ranges::input_range<T>)
-auto resultGenerator(T&& vector, size_t numItems, Transformation transformation = {}) {
+CPP_template(typename T, typename Transformation = std::identity)(
+    requires ql::ranges::input_range<T>) auto resultGenerator(T&& vector, size_t numItems,
+                                                              Transformation transformation = {}) {
   AD_CONTRACT_CHECK(numItems == vector.size());
   return ad_utility::allView(AD_FWD(vector)) | ql::views::transform(std::move(transformation));
 }

src/util/Algorithm.h

@@ -129,10 +129,10 @@ std::vector<T> flatten(std::vector<std::vector<T>>&& input) {
 // used to keep track of which values we have already seen. One of these
 // copies could be avoided, but our current uses of this function are
 // currently not at all performance-critical (small `input` and small `T`).
-template <typename Range>
-requires(ql::ranges::forward_range<Range>)
-auto removeDuplicates(const Range& input) -> std::vector<
-    typename std::iterator_traits<ql::ranges::iterator_t<Range>>::value_type> {
+CPP_template(typename Range)(requires ql::ranges::forward_range<
+                             Range>) auto removeDuplicates(const Range& input)
+    -> std::vector<typename std::iterator_traits<
+        ql::ranges::iterator_t<Range>>::value_type> {
   using T =
       typename std::iterator_traits<ql::ranges::iterator_t<Range>>::value_type;
   std::vector<T> result;

src/util/BlankNodeManager.h

@@ -90,9 +90,8 @@ class BlankNodeManager {
 
     // Merge passed `LocalBlankNodeManager`s to keep alive their reserved
     // BlankNodeIndex blocks.
-    template <typename R>
-    requires(ql::ranges::range<R>)
-    void mergeWith(const R& localBlankNodeManagers) {
+    CPP_template(typename R)(requires ql::ranges::range<R>) void mergeWith(
+        const R& localBlankNodeManagers) {
       auto inserter = std::back_inserter(otherBlocks_);
       for (const auto& l : localBlankNodeManagers) {
         if (l == nullptr) {

src/util/JoinAlgorithms/JoinAlgorithms.h

@@ -81,20 +81,20 @@ concept BinaryIteratorFunction =
  * described cases leads to two sorted ranges in the output, this can possibly
  * be exploited to fix the result in a cheaper way than a full sort.
  */
-template <typename Range1, typename Range2, typename LessThan,
-          typename FindSmallerUndefRangesLeft,
-          typename FindSmallerUndefRangesRight,
-          typename ElFromFirstNotFoundAction = decltype(noop),
-          typename CheckCancellation = decltype(noop)>
-requires(ql::ranges::random_access_range<Range1> &&
-         ql::ranges::random_access_range<Range2>)
-[[nodiscard]] auto zipperJoinWithUndef(
-    const Range1& left, const Range2& right, const LessThan& lessThan,
-    const auto& compatibleRowAction,
-    const FindSmallerUndefRangesLeft& findSmallerUndefRangesLeft,
-    const FindSmallerUndefRangesRight& findSmallerUndefRangesRight,
-    ElFromFirstNotFoundAction elFromFirstNotFoundAction = {},
-    CheckCancellation checkCancellation = {}) {
+CPP_template(typename Range1, typename Range2, typename LessThan,
+             typename FindSmallerUndefRangesLeft,
+             typename FindSmallerUndefRangesRight,
+             typename ElFromFirstNotFoundAction = decltype(noop),
+             typename CheckCancellation = decltype(noop))(
+    requires ql::ranges::random_access_range<Range1> CPP_and
+        ql::ranges::random_access_range<Range2>)
+    [[nodiscard]] auto zipperJoinWithUndef(
+        const Range1& left, const Range2& right, const LessThan& lessThan,
+        const auto& compatibleRowAction,
+        const FindSmallerUndefRangesLeft& findSmallerUndefRangesLeft,
+        const FindSmallerUndefRangesRight& findSmallerUndefRangesRight,
+        ElFromFirstNotFoundAction elFromFirstNotFoundAction = {},
+        CheckCancellation checkCancellation = {}) {
   // If this is not an OPTIONAL join or a MINUS we can apply several
   // optimizations, so we store this information.
   static constexpr bool hasNotFoundAction =
@@ -321,16 +321,20 @@ requires(ql::ranges::random_access_range<Range1> &&
  * a proper exception. Typically implementations will just
  * CancellationHandle::throwIfCancelled().
  */
-template <typename RangeSmaller, typename RangeLarger,
-          typename ElementFromSmallerNotFoundAction = Noop,
-          typename CheckCancellation = Noop>
-requires(ql::ranges::random_access_range<RangeSmaller> &&
-         ql::ranges::random_access_range<RangeLarger>)
-void gallopingJoin(
-    const RangeSmaller& smaller, const RangeLarger& larger,
-    auto const& lessThan, auto const& action,
-    ElementFromSmallerNotFoundAction elementFromSmallerNotFoundAction = {},
-    CheckCancellation checkCancellation = {}) {
+CPP_template(typename RangeSmaller, typename RangeLarger,
+             typename ElementFromSmallerNotFoundAction = Noop,
+             typename CheckCancellation = Noop)(
+    requires ql::ranges::random_access_range<RangeSmaller> CPP_and
+        ql::ranges::random_access_range<
+            RangeLarger>) void gallopingJoin(const RangeSmaller& smaller,
+                                             const RangeLarger& larger,
+                                             auto const& lessThan,
+                                             auto const& action,
+                                             ElementFromSmallerNotFoundAction
+                                                 elementFromSmallerNotFoundAction =
+                                                     {},
+                                             CheckCancellation
+                                                 checkCancellation = {}) {
   auto itSmall = std::begin(smaller);
   auto endSmall = std::end(smaller);
   auto itLarge = std::begin(larger);

src/util/StringUtils.h

@@ -105,19 +105,18 @@ streams.
 @param separator Will be put between each of the string representations
 of the range elements.
 */
-template <typename Range>
-requires(ql::ranges::input_range<Range> &&
-         ad_utility::Streamable<
-             std::iter_reference_t<ql::ranges::iterator_t<Range>>>)
-void lazyStrJoin(std::ostream* stream, Range&& r, std::string_view separator);
+CPP_template(typename Range)(
+    requires ql::ranges::input_range<Range> CPP_and
+        ad_utility::Streamable<std::iter_reference_t<ql::ranges::iterator_t<
+            Range>>>) void lazyStrJoin(std::ostream* stream, Range&& r,
+                                       std::string_view separator);
 
 // Similar to the overload of `lazyStrJoin` above, but the result is returned as
 // a string.
-template <typename Range>
-requires(ql::ranges::input_range<Range> &&
-         ad_utility::Streamable<
-             std::iter_reference_t<ql::ranges::iterator_t<Range>>>)
-std::string lazyStrJoin(Range&& r, std::string_view separator);
+CPP_template(typename Range)(
+    requires ql::ranges::input_range<Range> CPP_and ad_utility::Streamable<
+        std::iter_reference_t<ql::ranges::iterator_t<Range>>>) std::string
+    lazyStrJoin(Range&& r, std::string_view separator);
 
 /*
 @brief Adds indentation before the given string and directly after new line
@@ -192,11 +191,11 @@ constexpr bool constantTimeEquals(std::string_view view1,
 }
 
 // _________________________________________________________________________
-template <typename Range>
-requires(ql::ranges::input_range<Range> &&
-         ad_utility::Streamable<
-             std::iter_reference_t<ql::ranges::iterator_t<Range>>>)
-void lazyStrJoin(std::ostream* stream, Range&& r, std::string_view separator) {
+CPP_template(typename Range)(
+    requires ql::ranges::input_range<Range> CPP_and
+        ad_utility::Streamable<std::iter_reference_t<ql::ranges::iterator_t<
+            Range>>>) void lazyStrJoin(std::ostream* stream, Range&& r,
+                                       std::string_view separator) {
   auto begin = std::begin(r);
   auto end = std::end(r);
 
@@ -218,11 +217,10 @@ void lazyStrJoin(std::ostream* stream, Range&& r, std::string_view separator) {
 }
 
 // _________________________________________________________________________
-template <typename Range>
-requires(ql::ranges::input_range<Range> &&
-         ad_utility::Streamable<
-             std::iter_reference_t<ql::ranges::iterator_t<Range>>>)
-std::string lazyStrJoin(Range&& r, std::string_view separator) {
+CPP_template(typename Range)(
+    requires ql::ranges::input_range<Range> CPP_and ad_utility::Streamable<
+        std::iter_reference_t<ql::ranges::iterator_t<Range>>>) std::string
+    lazyStrJoin(Range&& r, std::string_view separator) {
   std::ostringstream stream;
   lazyStrJoin(&stream, AD_FWD(r), separator);
   return std::move(stream).str();