#include <MultiToken.h>

Public Member Functions
edm::EDGetTokenT< T >	get (const edm::Event &iEvent) const

int	getGoodTokenIndex () const

GoodIndexType	getGoodTokenIndexPtr () const

edm::Handle< T >	getHandle (const edm::Event &iEvent) const

edm::Handle< T >	getValidHandle (const edm::Event &iEvent) const

template<typename... Tags>
	MultiTokenT (edm::ConsumesCollector &&cc, Tags...tags)

template<typename S , typename... Tags>
	MultiTokenT (const MultiTokenT< S > &master, edm::ConsumesCollector &&cc, Tags...tags)

template<typename... Tags>
	MultiTokenT (edm::ConsumesCollector &&cc, const edm::ParameterSet &pset, Tags &&...tags)

template<typename S , typename... Tags>
	MultiTokenT (const MultiTokenT< S > &master, edm::ConsumesCollector &&cc, const edm::ParameterSet &pset, Tags &&...tags)

Private Types
using	GoodIndexType = std::shared_ptr< std::atomic< int >>

Private Member Functions
edm::Handle< T >	getInitialHandle (const edm::Event &iEvent) const

Private Attributes
const GoodIndexType	goodIndex_

const bool	isMaster_

const std::vector< edm::EDGetTokenT< T > >	tokens_

Detailed Description

template<typename T>
class MultiTokenT< T >

Definition at line 31 of file MultiToken.h.

Member Typedef Documentation

template<typename T>

using MultiTokenT< T >::GoodIndexType = std::shared_ptr<std::atomic<int>>

private

Definition at line 33 of file MultiToken.h.

Constructor & Destructor Documentation

template<typename T>

template<typename... Tags>

MultiTokenT< T >::MultiTokenT	(	edm::ConsumesCollector &&	cc,
		Tags...	tags
	)

inline

Definition at line 38 of file MultiToken.h.

       : isMaster_(true)
       , tokens_({cc.mayConsume<T>(edm::InputTag(tags))...})
       , goodIndex_(std::make_shared<std::atomic<int>>(-1))
     {}

template<typename T>

template<typename S , typename... Tags>

MultiTokenT< T >::MultiTokenT	(	const MultiTokenT< S > &	master,
		edm::ConsumesCollector &&	cc,
		Tags...	tags
	)

inline

Definition at line 46 of file MultiToken.h.

       : isMaster_(false)
       , tokens_({cc.mayConsume<T>(edm::InputTag(tags))...})
       , goodIndex_(master.getGoodTokenIndexPtr())
     {}

template<typename T>

template<typename... Tags>

MultiTokenT< T >::MultiTokenT	(	edm::ConsumesCollector &&	cc,
		const edm::ParameterSet &	pset,
		Tags &&...	tags
	)

inline

Definition at line 54 of file MultiToken.h.

       : isMaster_(true)
       , tokens_({cc.mayConsume<T>(pset.getParameter<edm::InputTag>(tags))...})
       , goodIndex_(std::make_shared<std::atomic<int>>(-1))
     {}

template<typename T>

template<typename S , typename... Tags>

MultiTokenT< T >::MultiTokenT	(	const MultiTokenT< S > &	master,
		edm::ConsumesCollector &&	cc,
		const edm::ParameterSet &	pset,
		Tags &&...	tags
	)

inline

Definition at line 62 of file MultiToken.h.

       : isMaster_(false)
       , tokens_({cc.mayConsume<T>(pset.getParameter<edm::InputTag>(tags))...})
       , goodIndex_(master.getGoodTokenIndexPtr())
     {}

Member Function Documentation

template<typename T>

edm::EDGetTokenT<T> MultiTokenT< T >::get ( const edm::Event & iEvent ) const

inline

Definition at line 123 of file MultiToken.h.

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), betterConfigParser.BetterConfigParser::getCompares(), and betterConfigParser.BetterConfigParser::getResultingSection().

     {
         // If we already know which token works, take that index
         if (*goodIndex_ >= 0)
             return tokens_[*goodIndex_];
 
         // If this is not a master MultiToken, just return what it got
         if (!isMaster_) {
             throw cms::Exception("MultiTokenTException") <<
                 "Trying to get a handle from a depending MultiToken before the master!";
         }
 
         // Find which token is the good one by trying to get a handle
         edm::Handle<T> handle;
         for (auto token:tokens_ ) {
             iEvent.getByToken(token, handle);
             if (handle.isValid()) {
                 return token;
             }
         }
 
         throw cms::Exception("MultiTokenTException") << "Neither token is valid!";
     }

template<typename T>

int MultiTokenT< T >::getGoodTokenIndex ( ) const

inline

Definition at line 147 of file MultiToken.h.

Referenced by PhotonIDValueMapProducer::produce().

     {
         return *goodIndex_;
     }

template<typename T>

GoodIndexType MultiTokenT< T >::getGoodTokenIndexPtr ( ) const

inline

Definition at line 152 of file MultiToken.h.

     {
         return goodIndex_;
     }

template<typename T>

edm::Handle<T> MultiTokenT< T >::getHandle ( const edm::Event & iEvent ) const

inline

Definition at line 69 of file MultiToken.h.

Referenced by ElectronMVANtuplizer::analyze().

     {
         edm::Handle<T> handle;
 
         // If we already know which token works, take that one
         if (*goodIndex_ >= 0) {
             iEvent.getByToken(tokens_[*goodIndex_], handle);
             return handle;
         }
 
         if (!isMaster_) {
             throw cms::Exception("MultiTokenTException") <<
                 "Trying to get a handle from a depending MultiToken before the master!";
         }
 
         // If not, set the good token index parallel to getting the handle
         handle = getInitialHandle(iEvent);
 
         if (*goodIndex_ == -1) {
             *goodIndex_ = tokens_.size() - 1;
         }
         return handle;
     }

template<typename T>

edm::Handle<T> MultiTokenT< T >::getInitialHandle ( const edm::Event & iEvent ) const

inlineprivate

Definition at line 159 of file MultiToken.h.

Referenced by MultiTokenT< edm::View< reco::GsfElectron > >::getHandle(), and MultiTokenT< edm::View< reco::GsfElectron > >::getValidHandle().

     {
         // Try to retrieve the collection from the event. If we fail to
         // retrieve the collection with one name, we next look for the one with
         // the other name and so on.
         edm::Handle<T> handle;
         for (size_t i = 0; i < tokens_.size(); ++i) {
             iEvent.getByToken(tokens_[i], handle);
             if (handle.isValid()) {
                 *goodIndex_ = i;
                 return handle;
             }
         }
         return handle;
     }

template<typename T>

edm::Handle<T> MultiTokenT< T >::getValidHandle ( const edm::Event & iEvent ) const

inline

Definition at line 95 of file MultiToken.h.

Referenced by PhotonMVANtuplizer::analyze(), ElectronMVANtuplizer::analyze(), ElectronIDValueMapProducer::produce(), MVAValueMapProducer< ParticleType >::produce(), and PhotonIDValueMapProducer::produce().

     {
         edm::Handle<T> handle;
 
         // If we already know which token works, take that one
         if (*goodIndex_ >= 0) {
             iEvent.getByToken(tokens_[*goodIndex_], handle);
             if (!handle.isValid())
                 throw cms::Exception("MultiTokenTException") <<
                     "Token gave valid handle previously but not anymore!";
             return handle;
         }
 
         if (!isMaster_) {
             throw cms::Exception("MultiTokenTException") <<
                 "Trying to get a handle from a depending MultiToken before the master!";
         }
 
         // If not, set the good token index parallel to getting the handle
         handle = getInitialHandle(iEvent);
 
         if (*goodIndex_ == -1) {
             throw cms::Exception("MultiTokenTException") << "Neither handle is valid!";
         }
         return handle;
     }