Convert FwdPtrCollectionFilter to stream filter

CommonTools/ParticleFlow/plugins/PFJetFwdPtrProducer.h

@@ -1,6 +1,5 @@
-#include "CommonTools/UtilAlgos/interface/FwdPtrCollectionFilter.h"
+#include "CommonTools/UtilAlgos/interface/FwdPtrProducer.h"
 #include "DataFormats/JetReco/interface/PFJet.h"
 #include "DataFormats/JetReco/interface/PFJetCollection.h"
-#include "CommonTools/UtilAlgos/interface/FwdPtrProducer.h"
 
 typedef edm::FwdPtrProducer< reco::PFJet >  PFJetFwdPtrProducer;

CommonTools/ParticleFlow/plugins/PFTauFwdPtrProducer.h

@@ -1,6 +1,5 @@
-#include "CommonTools/UtilAlgos/interface/FwdPtrCollectionFilter.h"
+#include "CommonTools/UtilAlgos/interface/FwdPtrProducer.h"
 #include "DataFormats/TauReco/interface/PFTau.h"
 #include "DataFormats/TauReco/interface/PFTauFwd.h"
-#include "CommonTools/UtilAlgos/interface/FwdPtrProducer.h"
 
 typedef edm::FwdPtrProducer< reco::PFTau >  PFTauFwdPtrProducer;

CommonTools/UtilAlgos/interface/FwdPtrCollectionFilter.h

@@ -1,115 +1,86 @@
 #ifndef CommonTools_UtilAlgos_FwdPtrCollectionFilter_h
 #define CommonTools_UtilAlgos_FwdPtrCollectionFilter_h
 
-
 /**
-  \class    edm::FwdPtrCollectionFilter FwdPtrCollectionFilter.h "CommonTools/UtilAlgos/interface/FwdPtrCollectionFilter.h"
-  \brief    Selects a list of FwdPtr's to a product T (templated) that satisfy a method S(T) (templated). Can also handle input as View<T>.
-            Can also have a factory class to create new instances of clones if desired.
-
+   \class    edm::FwdPtrCollectionFilter FwdPtrCollectionFilter.h "CommonTools/UtilAlgos/interface/FwdPtrCollectionFilter.h"
+   \brief    Selects a list of FwdPtr's to a product T (templated) that satisfy a method S(T) (templated). Can also handle input as View<T>.
+   Can also have a factory class to create new instances of clones if desired.
 
-  \author   Salvatore Rappoccio
+   \author   Salvatore Rappoccio
 */
 
-
-#include "FWCore/Framework/interface/EDFilter.h"
+#include "CommonTools/UtilAlgos/interface/FwdPtrConversionFactory.h"
+#include "DataFormats/Common/interface/FwdPtr.h"
+#include "DataFormats/Common/interface/View.h"
+#include "FWCore/Framework/interface/stream/EDFilter.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/Utilities/interface/InputTag.h"
-#include "DataFormats/Common/interface/View.h"
-#include "DataFormats/Common/interface/FwdPtr.h"
-#include "CommonTools/UtilAlgos/interface/FwdPtrConversionFactory.h"
+
+#include <algorithm>
 #include <vector>
 
 namespace edm {
 
-  template < class T, class S, class H = ProductFromFwdPtrFactory<T> >
-  class FwdPtrCollectionFilter : public edm::EDFilter {
+  template <class T, class S, class H = ProductFromFwdPtrFactory<T>>
+  class FwdPtrCollectionFilter : public edm::stream::EDFilter<> {
   public :
-    explicit FwdPtrCollectionFilter() {}
 
-    explicit FwdPtrCollectionFilter( edm::ParameterSet const & params ) :
-    srcToken_( consumes< std::vector< edm::FwdPtr<T> > >( params.getParameter<edm::InputTag>("src") ) ),
-    srcViewToken_( mayConsume< edm::View<T>  >( params.getParameter<edm::InputTag>("src") ) ),
-    filter_(false), makeClones_(false),
-      selector_( params )
+    explicit FwdPtrCollectionFilter(edm::ParameterSet const& ps) :
+      srcToken_{consumes<std::vector<edm::FwdPtr<T>>>(ps.getParameter<edm::InputTag>("src"))},
+      srcViewToken_{mayConsume<edm::View<T>>(ps.getParameter<edm::InputTag>("src"))},
+      filter_{ps.exists("filter") ? ps.getParameter<bool>("filter") : false},
+      makeClones_{ps.exists("makeClones") ? ps.getParameter<bool>("makeClones") : false},
+      selector_{ps}
     {
-      if ( params.exists("filter") ) {
-	filter_ = params.getParameter<bool>("filter");
-      }
-      if ( params.exists("makeClones") ) {
-	makeClones_ = params.getParameter<bool>("makeClones");
-      }
-
-      produces< std::vector< edm::FwdPtr<T> > > ();
-      if ( makeClones_ ) {
-	produces< std::vector<T> > ();
+      produces<std::vector<edm::FwdPtr<T>>>();
+      if (makeClones_) {
+        produces<std::vector<T>>();
       }
     }
 
-    ~FwdPtrCollectionFilter() {}
-
-    virtual bool filter(edm::Event & iEvent, const edm::EventSetup& iSetup){
-
-      std::unique_ptr< std::vector< edm::FwdPtr<T> > > pOutput ( new std::vector<edm::FwdPtr<T> > );
-
-      std::unique_ptr< std::vector<T> > pClones ( new std::vector<T> );
-
+    bool filter(edm::Event& iEvent, edm::EventSetup const& iSetup) override
+    {
+      auto pOutput = std::make_unique<std::vector<edm::FwdPtr<T>>>();
 
-      edm::Handle< std::vector< edm::FwdPtr<T> > > hSrcAsFwdPtr;
-      edm::Handle< edm::View<T> > hSrcAsView;
-      bool foundAsFwdPtr = iEvent.getByToken( srcToken_, hSrcAsFwdPtr );
-      if ( !foundAsFwdPtr ) {
-	iEvent.getByToken( srcViewToken_, hSrcAsView );
+      // First try to access as a vector<FwdPtr<T>>; otherwise try as a View<T>.
+      edm::Handle<std::vector<edm::FwdPtr<T>>> hSrcAsFwdPtr;
+      if (iEvent.getByToken(srcToken_, hSrcAsFwdPtr)) {
+        std::copy_if(std::cbegin(*hSrcAsFwdPtr), std::cend(*hSrcAsFwdPtr), std::back_inserter(*pOutput),
+                     [this](auto const ptr) { return selector_(*ptr); });
+      }
+      else {
+        edm::Handle<edm::View<T>> hSrcAsView;
+        iEvent.getByToken(srcViewToken_, hSrcAsView);
+        for (auto ibegin = std::cbegin(*hSrcAsView), iend = std::cend(*hSrcAsView), i = ibegin; i!= iend; ++i) {
+          if (selector_(*i)) {
+            auto const p = hSrcAsView->ptrAt(i-ibegin);
+            pOutput->emplace_back(p,p);
+          }
+        }
       }
 
-      // First try to access as a View<T>. If not a View<T>, look as a vector<FwdPtr<T> >
-      if ( !foundAsFwdPtr ) {
-	for ( typename edm::View<T>::const_iterator ibegin = hSrcAsView->begin(),
-		iend = hSrcAsView->end(),
-		i = ibegin; i!= iend; ++i ) {
-	  if ( selector_( *i ) ) {
-	    pOutput->push_back( edm::FwdPtr<T>( hSrcAsView->ptrAt( i - ibegin ), hSrcAsView->ptrAt( i - ibegin ) ) );
-	    if ( makeClones_ ) {
-	      H factory;
-	      T outclone = factory( pOutput->back() );
-	      pClones->push_back( outclone );
-	    }
-	  }
-	}
-      } else {
-	for ( typename std::vector<edm::FwdPtr<T> >::const_iterator ibegin = hSrcAsFwdPtr->begin(),
-		iend = hSrcAsFwdPtr->end(),
-		i = ibegin; i!= iend; ++i ) {
-	  if ( selector_( **i ) ) {
-	    pOutput->push_back( *i );
-	    if ( makeClones_ ) {
-	      H factory;
-	      T outclone = factory( pOutput->back() );
-	      pClones->push_back( outclone );
-	    }
-	  }
-	}
-
+      // Must form pClones *before* std::move(pOutput) has been called.
+      if (makeClones_) {
+        H factory;
+        auto pClones = std::make_unique<std::vector<T>>();
+        std::transform(std::cbegin(*pOutput), std::cend(*pOutput), std::back_inserter(*pClones),
+                       [&factory](auto ptr){ return factory(ptr); });
+        iEvent.put(std::move(pClones));
       }
 
-      bool pass = pOutput->size() > 0;
+      bool const pass {!pOutput->empty()};
       iEvent.put(std::move(pOutput));
-      if ( makeClones_ )
-	iEvent.put(std::move(pClones));
-      if ( filter_ )
-	return pass;
-      else
-	return true;
 
+      return filter_ ? pass : true;
     }
 
   protected :
-    edm::EDGetTokenT< std::vector< edm::FwdPtr<T> > > srcToken_;
-    edm::EDGetTokenT< edm::View<T>  > srcViewToken_;
-    bool          filter_;
-    bool          makeClones_;
-    S             selector_;
+    edm::EDGetTokenT<std::vector<edm::FwdPtr<T>>> const srcToken_;
+    edm::EDGetTokenT<edm::View<T>> const srcViewToken_;
+    bool const filter_;
+    bool const makeClones_;
+    S selector_;
   };
 }