Added and_then function to Service class

Instead of testing for `isAvailable` and then running some code, one can pass the code to `and_then`. This mirrors what std::optional does in C++23.

Author: Dr15Jones

FWCore/ServiceRegistry/interface/Service.h

@@ -19,14 +19,15 @@
 //
 
 // system include files
+#include <optional>
 
 // user include files
 #include "FWCore/ServiceRegistry/interface/ServiceRegistry.h"
 
 // forward declarations
 
 namespace edm {
-  template <class T>
+  template <typename T>
   class Service {
   public:
     Service() {}
@@ -41,6 +42,28 @@ namespace edm {
 
     operator bool() const { return isAvailable(); }
 
+    ///iF should be a functor and will only be called if the Service is available
+    template <typename F>
+      requires(!requires(F&& iF, T* t) {
+                { iF(*t) } -> std::same_as<void>;
+              })
+    auto and_then(F&& iF, T* t) -> std::optional<decltype(iF(*t))> const {
+      if (isAvailable()) {
+        return iF(*(operator->()));
+      }
+      return std::nullopt;
+    }
+
+    template <typename F>
+      requires(requires(F&& iF, T* t) {
+        { iF(*t) } -> std::same_as<void>;
+      })
+    void and_then(F&& iF) const {
+      if (isAvailable()) {
+        iF(*(operator->()));
+      }
+    }
+
     // ---------- static member functions --------------------
 
     // ---------- member functions ---------------------------

IOMC/RandomEngine/plugins/RandomEngineStateProducer.cc

@@ -19,22 +19,20 @@ RandomEngineStateProducer::RandomEngineStateProducer(edm::ParameterSet const&) {
 RandomEngineStateProducer::~RandomEngineStateProducer() {}
 
 void RandomEngineStateProducer::produce(edm::StreamID iID, edm::Event& ev, edm::EventSetup const&) const {
-  edm::Service<edm::RandomNumberGenerator> randomService;
-  if (randomService.isAvailable()) {
+  edm::Service<edm::RandomNumberGenerator>().and_then([&ev](auto const& randomService) {
     auto states = std::make_unique<edm::RandomEngineStates>();
-    states->setRandomEngineStates(randomService->getEventCache(ev.streamID()));
+    states->setRandomEngineStates(randomService.getEventCache(ev.streamID()));
     ev.put(std::move(states));
-  }
+  });
 }
 
 void RandomEngineStateProducer::globalBeginLuminosityBlockProduce(edm::LuminosityBlock& lb,
                                                                   edm::EventSetup const&) const {
-  edm::Service<edm::RandomNumberGenerator> randomService;
-  if (randomService.isAvailable()) {
+  edm::Service<edm::RandomNumberGenerator>().and_then([&lb](auto const& randomService) {
     auto states = std::make_unique<edm::RandomEngineStates>();
-    states->setRandomEngineStates(randomService->getLumiCache(lb.index()));
+    states->setRandomEngineStates(randomService.getLumiCache(lb.index()));
     lb.put(std::move(states), "beginLumi");
-  }
+  });
 }
 
 void RandomEngineStateProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {