Added firstIf to chaining task system

Author: Dr15Jones

FWCore/Concurrency/interface/chain_first.h

@@ -177,6 +177,39 @@ namespace edm {
       U f_;
     };
 
+    template <typename U>
+    struct WaitingTaskChain<Conditional<U>> {
+      constexpr explicit WaitingTaskChain(bool iValue, U&& iU) : f_{std::forward<U>(iU)}, conditional_(iValue) {}
+
+      [[nodiscard]] WaitingTaskHolder lastTask(WaitingTaskHolder iV) {
+        if (conditional_) {
+          return WaitingTaskHolder(
+              *iV.group(),
+              make_waiting_task([f = std::move(f_), v = std::move(iV)](const std::exception_ptr* iPtr) mutable {
+                f(iPtr, std::move(v));
+              }));
+        }
+        return iV;
+      }
+
+      void runLast(WaitingTaskHolder iH) {
+        if (conditional_) {
+          f_(nullptr, std::move(iH));
+        } else {
+          iH.doneWaiting(std::exception_ptr{});
+        }
+      }
+
+      template <typename V>
+      friend auto operator|(WaitingTaskChain<Conditional<U>> iChain, V&& iV) {
+        return iV.pipe(std::move(iChain));
+      }
+
+    private:
+      U f_;
+      bool conditional_;
+    };
+
     template <typename U, typename... T>
     struct WaitingTaskChain<U, T...> {
       explicit constexpr WaitingTaskChain(U&& iU, WaitingTaskChain<T...> iL)
@@ -266,6 +299,20 @@ namespace edm {
       }
     }
 
+    /** Sets the first task to be run as part of the task chain, if the value is true, else the following task will be first. The functor is expected to take either
+   a single argument of type edm::WaitingTaskHolder or two arguments of type std::exception_ptr const* and WaitingTaskHolder. In the latter case, the pointer is only non-null if a previous task in the chain threw an exception.
+   */
+    template <typename F>
+    [[nodiscard]] constexpr auto firstIf(bool iValue, F&& iF) {
+      using namespace detail;
+      if constexpr (has_exception_handling<F>::value) {
+        return WaitingTaskChain<Conditional<F>>(iValue, std::forward<F>(iF));
+      } else {
+        return WaitingTaskChain<Conditional<AutoExceptionHandler<F>>>(iValue,
+                                                                      AutoExceptionHandler<F>(std::forward<F>(iF)));
+      }
+    }
+
     /**Define next task to run once this task has finished. Two different functor types are allowed
    1. The functor  takes a edm::WaitingTaskHolder as argument. If an exception happened in a previous task, the functor will NOT be run.
    If an exception happens while running the functor, the exception will be propagated to the WaitingTaskHolder.

FWCore/Concurrency/test/test_catch2_WaitingTaskChain.cc

@@ -513,4 +513,47 @@ TEST_CASE("Test chain::first", "[chain::first]") {
       REQUIRE(not waitTask.exceptionPtr());
     }
   }
+  SECTION("firstIf testing") {
+    SECTION("firstIf(true) | then | runLast") {
+      std::atomic<int> count{0};
+
+      oneapi::tbb::task_group group;
+      edm::FinalWaitingTask waitTask{group};
+      {
+        using namespace edm::waiting_task::chain;
+        firstIf(true, [&count](auto h) {
+          ++count;
+          REQUIRE(count.load() == 1);
+        }) | then([&count](auto h) {
+          ++count;
+          REQUIRE(count.load() == 2);
+        }) | runLast(edm::WaitingTaskHolder(group, &waitTask));
+      }
+      waitTask.waitNoThrow();
+      REQUIRE(count.load() == 2);
+      REQUIRE(waitTask.done());
+      REQUIRE(not waitTask.exceptionPtr());
+    }
+
+    SECTION("first(false) | then | runLast") {
+      std::atomic<int> count{0};
+
+      oneapi::tbb::task_group group;
+      edm::FinalWaitingTask waitTask{group};
+      {
+        using namespace edm::waiting_task::chain;
+        firstIf(false, [&count](auto h) {
+          ++count;
+          REQUIRE(false);
+        }) | then([&count](auto h) {
+          ++count;
+          REQUIRE(count.load() == 1);
+        }) | runLast(edm::WaitingTaskHolder(group, &waitTask));
+      }
+      waitTask.waitNoThrow();
+      REQUIRE(count.load() == 1);
+      REQUIRE(waitTask.done());
+      REQUIRE(not waitTask.exceptionPtr());
+    }
+  }
 }