#include <DataGetterHelper.h>

Public Member Functions
	DataGetterHelper (TTree *tree, std::shared_ptr< HistoryGetterBase > historyGetter, std::shared_ptr< BranchMapReader > branchMap=std::shared_ptr< BranchMapReader >(), std::shared_ptr< edm::EDProductGetter > getter=std::shared_ptr< edm::EDProductGetter >(), bool useCache=false)

virtual std::string const	getBranchNameFor (std::type_info const &, char const , char const , char const *) const

virtual bool	getByLabel (std::type_info const &, char const , char const , char const , void , Long_t) const

edm::WrapperBase const *	getByProductID (edm::ProductID const &pid, Long_t eventEntry) const

edm::EDProductGetter *	getter ()

edm::WrapperBase const *	getThinnedProduct (edm::ProductID const &pid, unsigned int &key, Long_t eventEntry) const

void	getThinnedProducts (edm::ProductID const &pid, std::vector< edm::WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys, Long_t eventEntry) const

void	setGetter (std::shared_ptr< edm::EDProductGetter > getter)

virtual	~DataGetterHelper ()

Private Types
typedef std::map < internal::DataKey, std::shared_ptr < internal::Data > >	KeyToDataMap

Private Member Functions
	DataGetterHelper (const DataGetterHelper &)

void	getBranchData (edm::EDProductGetter *, Long64_t, internal::Data &) const

internal::Data &	getBranchDataFor (std::type_info const &, char const , char const , char const *) const

bool	getByBranchDescription (edm::BranchDescription const &, Long_t eventEntry, KeyToDataMap::iterator &) const

edm::WrapperBase const *	getByBranchID (edm::BranchID const &bid, Long_t eventEntry) const

edm::ThinnedAssociation const *	getThinnedAssociation (edm::BranchID const &branchID, Long_t eventEntry) const

const edm::ProcessHistory &	history () const

const DataGetterHelper &	operator= (const DataGetterHelper &)

edm::WrapperBase const *	wrapperBasePtr (edm::ObjectWithDict const &) const

Private Attributes
std::map< edm::BranchID, std::shared_ptr < internal::Data > >	bidToData_

std::shared_ptr< BranchMapReader >	branchMap_

KeyToDataMap	data_

std::shared_ptr < edm::EDProductGetter >	getter_

std::shared_ptr < fwlite::HistoryGetterBase >	historyGetter_

std::map< std::pair < edm::ProductID, edm::BranchListIndex > , std::shared_ptr < internal::Data > >	idToData_

std::vector< char const * >	labels_

bool	tcTrained_

TTree *	tree_

Detailed Description

Definition at line 52 of file DataGetterHelper.h.

Member Typedef Documentation

typedef std::map<internal::DataKey, std::shared_ptr<internal::Data> > fwlite::DataGetterHelper::KeyToDataMap

private

Definition at line 96 of file DataGetterHelper.h.

Constructor & Destructor Documentation

DataGetterHelper::DataGetterHelper	(	TTree *	tree,
		std::shared_ptr< HistoryGetterBase >	historyGetter,
		std::shared_ptr< BranchMapReader >	branchMap = `std::shared_ptr<BranchMapReader>()`,
		std::shared_ptr< edm::EDProductGetter >	getter = `std::shared_ptr<edm::EDProductGetter>()`,
		bool	useCache = `false`
	)

Definition at line 51 of file DataGetterHelper.cc.

References Exception, MainPageGenerator::tree, and tree_.

                                                      :
         branchMap_(branchMap),
         historyGetter_(historyGetter),
         getter_(getter),
         tcTrained_(false)
     {
         if(0==tree) {
             throw cms::Exception("NoTree")<<"The TTree pointer passed to the constructor was null";
         }
         tree_ = tree;
         if (useCache) {
             tree_->SetCacheSize();
         }
     }

DataGetterHelper::~DataGetterHelper ( )

virtual

Definition at line 75 of file DataGetterHelper.cc.

75 {}

fwlite::DataGetterHelper::DataGetterHelper ( const DataGetterHelper & )

private

Member Function Documentation

void DataGetterHelper::getBranchData	(	edm::EDProductGetter *	iGetter,
		Long64_t	eventEntry,
		internal::Data &	iData
	)		const

private

Definition at line 114 of file DataGetterHelper.cc.

References fwlite::internal::Data::branch_, branchMap_, fwlite::internal::Data::lastProduct_, tcTrained_, and tree_.

Referenced by getByBranchID(), getByLabel(), and getByProductID().

     {
         GetterOperate op(iGetter);
 
         //edm::ObjectWithDict obj = iData.obj_;
         //iData.obj_ = iData.obj_.construct();
         //iData.pObj_ = iData.obj_.address();
         //iData.branch_->SetAddress(&(iData.pObj_));
         //if(0!=iData.pProd_) {
         //    iData.pProd_ = iData.obj_.address();
         //}
         //obj.destruct();
 
         TTreeCache* tcache = dynamic_cast<TTreeCache*> (branchMap_->getFile()->GetCacheRead());
 
         if (0 == tcache) {
             iData.branch_->GetEntry(eventEntry);
         } else {
             if (!tcTrained_) {
                 tcache->SetLearnEntries(100);
                 tcache->SetEntryRange(0, tree_->GetEntries());
                 tcTrained_ = true;
             }
             tree_->LoadTree(eventEntry);
             iData.branch_->GetEntry(eventEntry);
        }
        iData.lastProduct_=eventEntry;
     }

internal::Data & DataGetterHelper::getBranchDataFor	(	std::type_info const &	iInfo,
		char const *	iModuleLabel,
		char const *	iProductInstanceLabel,
		char const *	iProcessLabel
	)		const

private

Definition at line 151 of file DataGetterHelper.cc.

References edm::ObjectWithDict::address(), fwlite::branchNotFound, edm::ObjectWithDict::byType(), data_, Exception, fwlite::findBranch(), edm::TypeID::friendlyClassName(), h, history(), fwlite::internal::DataKey::kEmpty(), relval_steps::key, labels_, fwlite::internal::DataKey::module(), mergeVDriftHistosByStation::name, edm::TypeWithDict::name(), getGTfromDQMFile::obj, fwlite::internal::DataKey::process(), fwlite::internal::DataKey::product(), edm::ProcessHistory::rbegin(), edm::ProcessHistory::rend(), cmsHarvester::sep, AlCaHLTBitMon_QueryRunRegistry::string, and tree_.

Referenced by getBranchNameFor(), and getByLabel().

     {
         edm::TypeID type(iInfo);
         internal::DataKey key(type, iModuleLabel, iProductInstanceLabel, iProcessLabel);
 
         KeyToDataMap::iterator itFind = data_.find(key);
         if(itFind == data_.end()) {
             //see if such a branch actually exists
             std::string const sep("_");
             //CHANGE: If this fails, need to lookup the the friendly name which was used to write the file
             std::string name(type.friendlyClassName());
             name +=sep+std::string(key.module());
             name +=sep+std::string(key.product())+sep;
 
             //if we have to lookup the process label, remember it and register the product again
             std::string foundProcessLabel;
             TBranch* branch = 0;
             std::shared_ptr<internal::Data> theData;
 
             if (0==iProcessLabel || iProcessLabel==key.kEmpty() ||
                 strlen(iProcessLabel)==0) {
                 std::string const* lastLabel=0;
                 //have to search in reverse order since newest are on the bottom
                 const edm::ProcessHistory& h = DataGetterHelper::history();
                 for (edm::ProcessHistory::const_reverse_iterator iproc = h.rbegin(), eproc = h.rend();
                     iproc != eproc;
                     ++iproc) {
 
                     lastLabel = &(iproc->processName());
                     branch=findBranch(tree_,name,iproc->processName());
                     if(0!=branch) {
                     break;
                     }
                 }
                 if(0==branch) {
                     return branchNotFound;
                 }
                 //do we already have this one?
                 if(0!=lastLabel) {
                     internal::DataKey fullKey(type,iModuleLabel,iProductInstanceLabel,lastLabel->c_str());
                     itFind = data_.find(fullKey);
                     if(itFind != data_.end()) {
                         //remember the data we've found
                         theData = itFind->second;
                     } else {
                         //only set this if we don't already have it since it this string is not empty we re-register
                         foundProcessLabel = *lastLabel;
                     }
                 }
             } else {
                 //we have all the pieces
                 branch = findBranch(tree_,name,key.process());
                 if(0==branch){
                     return branchNotFound;
                 }
             }
 
             //cache the info
             size_t moduleLabelLen = strlen(iModuleLabel)+1; 
             char* newModule = new char[moduleLabelLen];
             std::strncpy(newModule,iModuleLabel,moduleLabelLen);
             labels_.push_back(newModule);
 
             char* newProduct = const_cast<char*>(key.product());
             if(newProduct[0] != 0) {
                 size_t newProductLen = strlen(newProduct)+1; 
                 newProduct = new char[newProductLen];
                 std::strncpy(newProduct,key.product(),newProductLen);
                 labels_.push_back(newProduct);
             }
             char* newProcess = const_cast<char*>(key.process());
             if(newProcess[0]!=0) {
                 size_t newProcessLen = strlen(newProcess)+1; 
                 newProcess = new char[newProcessLen];
                 std::strncpy(newProcess,key.process(),newProcessLen);
                 labels_.push_back(newProcess);
             }
             internal::DataKey newKey(edm::TypeID(iInfo),newModule,newProduct,newProcess);
 
             if(0 == theData.get()) {
                 //We do not already have this data as another key
 
                 //create an instance of the object to be used as a buffer
                 edm::TypeWithDict type(iInfo);
                 if(!bool(type)) {
                     throw cms::Exception("UnknownType") << "No dictionary exists for type " << iInfo.name();
                 }
 
                 edm::ObjectWithDict obj = edm::ObjectWithDict::byType(type);
 
                 if(obj.address() == nullptr) {
                     throw cms::Exception("ConstructionFailed") << "failed to construct an instance of " << type.name();
                 }
                 auto newData = std::make_shared<internal::Data>();
                 newData->branch_ = branch;
                 newData->obj_ = obj;
                 newData->lastProduct_ = -1;
                 newData->pObj_ = obj.address();
                 newData->pProd_ = nullptr;
                 branch->SetAddress(&(newData->pObj_));
                 theData = newData;
             }
             itFind = data_.insert(std::make_pair(newKey, theData)).first;
 
             if(foundProcessLabel.size()) {
                 //also remember it with the process label
                 newProcess = new char[foundProcessLabel.size()+1];
                 std::strcpy(newProcess,foundProcessLabel.c_str());
                 labels_.push_back(newProcess);
                 internal::DataKey newKey(edm::TypeID(iInfo),newModule,newProduct,newProcess);
 
                 data_.insert(std::make_pair(newKey,theData));
             }
         }
         return *(itFind->second);
     }

std::string const DataGetterHelper::getBranchNameFor	(	std::type_info const &	iInfo,
		char const *	iModuleLabel,
		char const *	iProductInstanceLabel,
		char const *	iProcessLabel
	)		const

virtual

Definition at line 272 of file DataGetterHelper.cc.

References fwlite::internal::Data::branch_, getBranchDataFor(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by fwlite::Run::getBranchNameFor(), fwlite::LuminosityBlock::getBranchNameFor(), and fwlite::Event::getBranchNameFor().

     {
         internal::Data& theData =
             DataGetterHelper::getBranchDataFor(iInfo, iModuleLabel, iProductInstanceLabel, iProcessLabel);
 
         if (0 != theData.branch_) {
             return std::string(theData.branch_->GetName());
         }
         return std::string("");
     }

bool DataGetterHelper::getByBranchDescription	(	edm::BranchDescription const &	bDesc,
		Long_t	eventEntry,
		KeyToDataMap::iterator &	itData
	)		const

private

Definition at line 313 of file DataGetterHelper.cc.

References assert(), edm::BranchDescription::branchID(), edm::TypeWithDict::byName(), data_, edm::BranchDescription::fullClassName(), getByLabel(), edm::BranchID::isValid(), relval_steps::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), and edm::wrappedClassName().

Referenced by getByBranchID(), and getByProductID().

                                                                                  {
       if (!bDesc.branchID().isValid()) {
         return false;
       }
 
       //Calculate the key from the branch description
       edm::TypeWithDict typeWD(edm::TypeWithDict::byName(edm::wrappedClassName(bDesc.fullClassName())));
       edm::TypeID type(typeWD.typeInfo());
       assert(bool(type));
 
       //Only the product instance label may be empty
       char const* pIL = bDesc.productInstanceName().c_str();
       if(pIL[0] == 0) {
         pIL = 0;
       }
       internal::DataKey k(type,
                           bDesc.moduleLabel().c_str(),
                           pIL,
                           bDesc.processName().c_str());
 
       //has this already been gotten?
       itData = data_.find(k);
       if(data_.end() == itData) {
         //ask for the data
         edm::WrapperBase const* dummy = nullptr;
         getByLabel(type.typeInfo(),
                    k.module(),
                    k.product(),
                    k.process(),
                    &dummy, eventEntry);
         if(nullptr == dummy) {
           return false;
         }
         itData = data_.find(k);
         assert(itData != data_.end());
         assert(dummy == itData->second->obj_.address());
       }
       return true;
     }

edm::WrapperBase const * DataGetterHelper::getByBranchID	(	edm::BranchID const &	bid,
		Long_t	eventEntry
	)		const

private

Definition at line 385 of file DataGetterHelper.cc.

References bidToData_, branchMap_, getBranchData(), getByBranchDescription(), getter_, and wrapperBasePtr().

Referenced by getThinnedAssociation().

     {
         auto itFound = bidToData_.find(bid);
 
         if(itFound == bidToData_.end()) {
             edm::BranchDescription const& bDesc = branchMap_->branchIDToBranch(bid);
             KeyToDataMap::iterator itData;
 
             if(!getByBranchDescription(bDesc, eventEntry, itData)) {
               return nullptr;
             }
             itFound = bidToData_.insert(std::make_pair(bid,itData->second)).first;
         }
         if(eventEntry != itFound->second->lastProduct_) {
             //haven't gotten the data for this event
             getBranchData(getter_.get(), eventEntry, *(itFound->second));
         }
         if(nullptr == itFound->second->pProd_) {
             itFound->second->pProd_ = wrapperBasePtr(itFound->second->obj_);
             if(nullptr == itFound->second->pProd_) {
                 return nullptr;
             }
         }
         return itFound->second->pProd_;
     }

bool DataGetterHelper::getByLabel	(	std::type_info const &	iInfo,
		char const *	iModuleLabel,
		char const *	iProductInstanceLabel,
		char const *	iProcessLabel,
		void *	oData,
		Long_t	eventEntry
	)		const

virtual

Definition at line 287 of file DataGetterHelper.cc.

References edm::ObjectWithDict::address(), fwlite::internal::Data::branch_, getBranchData(), getBranchDataFor(), getter_, fwlite::internal::Data::lastProduct_, and fwlite::internal::Data::obj_.

Referenced by getByBranchDescription(), fwlite::Run::getByLabel(), fwlite::LuminosityBlock::getByLabel(), and fwlite::Event::getByLabel().

     {
         // Maintain atEnd() check in parent classes
         void** pOData = reinterpret_cast<void**>(oData);
         *pOData = nullptr;
 
         internal::Data& theData =
             DataGetterHelper::getBranchDataFor(iInfo, iModuleLabel, iProductInstanceLabel, iProcessLabel);
 
         if (0 != theData.branch_) {
             if(eventEntry != theData.lastProduct_) {
                 //haven't gotten the data for this event
                 getBranchData(getter_.get(), eventEntry, theData);
             }
             *pOData = theData.obj_.address();
         }
 
         if (nullptr == *pOData) return false;
         else return true;
     }

edm::WrapperBase const * DataGetterHelper::getByProductID	(	edm::ProductID const &	pid,
		Long_t	eventEntry
	)		const

Definition at line 356 of file DataGetterHelper.cc.

References branchMap_, getBranchData(), getByBranchDescription(), getter_, idToData_, edm::ProductID::processIndex(), and wrapperBasePtr().

Referenced by fwlite::Run::getByProductID(), fwlite::LuminosityBlock::getByProductID(), fwlite::Event::getByProductID(), getThinnedProduct(), and getThinnedProducts().

     {
         typedef std::pair<edm::ProductID,edm::BranchListIndex> IDPair;
         IDPair theID = std::make_pair(iID, branchMap_->branchListIndexes()[iID.processIndex()-1]);
         std::map<IDPair,std::shared_ptr<internal::Data> >::const_iterator itFound = idToData_.find(theID);
 
         if(itFound == idToData_.end()) {
             edm::BranchDescription const& bDesc = branchMap_->productToBranch(iID);
             KeyToDataMap::iterator itData;
 
             if(!getByBranchDescription(bDesc, eventEntry, itData)) {
               return nullptr;
             }
             itFound = idToData_.insert(std::make_pair(theID,itData->second)).first;
         }
         if(eventEntry != itFound->second->lastProduct_) {
             //haven't gotten the data for this event
             getBranchData(getter_.get(), eventEntry, *(itFound->second));
         }
         if(nullptr == itFound->second->pProd_) {
             itFound->second->pProd_ = wrapperBasePtr(itFound->second->obj_);
             if(nullptr == itFound->second->pProd_) {
                 return nullptr;
             }
          }
          return itFound->second->pProd_;
     }

edm::EDProductGetter* fwlite::DataGetterHelper::getter ( )

inline

Definition at line 87 of file DataGetterHelper.h.

References getter_.

Referenced by fwlite::Event::draw(), fwlite::Event::scan(), and setGetter().

                                          {
                return getter_.get();
             }

edm::ThinnedAssociation const * DataGetterHelper::getThinnedAssociation	(	edm::BranchID const &	branchID,
		Long_t	eventEntry
	)		const

private

Definition at line 532 of file DataGetterHelper.cc.

References compareJSON::const, edm::WrapperBase::dynamicTypeInfo(), Exception, getByBranchID(), edm::errors::LogicError, edm::Wrapper< T >::product(), and wrapper.

Referenced by getThinnedProduct(), and getThinnedProducts().

                                                                                                 {
 
         edm::WrapperBase const* wrapperBase = getByBranchID(branchID, eventEntry);
         if(wrapperBase == nullptr) {
             throw edm::Exception(edm::errors::LogicError)
               << "DataGetterHelper::getThinnedAssociation, product ThinnedAssociation not found.\n";
         }
         if(!(typeid(edm::ThinnedAssociation) == wrapperBase->dynamicTypeInfo())) {
             throw edm::Exception(edm::errors::LogicError)
               << "DataGetterHelper::getThinnedAssociation, product has wrong type, not a ThinnedAssociation.\n";
         }
         edm::Wrapper<edm::ThinnedAssociation> const* wrapper =
             static_cast<edm::Wrapper<edm::ThinnedAssociation> const*>(wrapperBase);
 
         edm::ThinnedAssociation const* thinnedAssociation = wrapper->product();
         return thinnedAssociation;
     }

edm::WrapperBase const * DataGetterHelper::getThinnedProduct	(	edm::ProductID const &	pid,
		unsigned int &	key,
		Long_t	eventEntry
	)		const

Definition at line 420 of file DataGetterHelper.cc.

References branchMap_, getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BranchID::isValid(), dbtoconf::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), and edm::ThinnedAssociation::thinnedCollectionID().

Referenced by fwlite::Event::getThinnedProduct().

                                                                                                            {
 
         edm::BranchID parent = branchMap_->productToBranchID(pid);
         if(!parent.isValid()) return nullptr;
         edm::ThinnedAssociationsHelper const& thinnedAssociationsHelper = branchMap_->thinnedAssociationsHelper();
 
         // Loop over thinned containers which were made by selecting elements from the parent container
         for(auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent),
                                iEnd = thinnedAssociationsHelper.parentEnd(parent);
             associatedBranches != iEnd; ++associatedBranches) {
 
             edm::ThinnedAssociation const* thinnedAssociation =
                 getThinnedAssociation(associatedBranches->association(), eventEntry);
             if(thinnedAssociation == nullptr) continue;
 
             if(associatedBranches->parent() != branchMap_->productToBranchID(thinnedAssociation->parentCollectionID())) {
               continue;
             }
 
             unsigned int thinnedIndex = 0;
             // Does this thinned container have the element referenced by key?
             // If yes, thinnedIndex is set to point to it in the thinned container
             if(!thinnedAssociation->hasParentIndex(key, thinnedIndex)) {
                 continue;
             }
             // Get the thinned container and return a pointer if we can find it
             edm::ProductID const& thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
             edm::WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID, eventEntry);
 
             if(thinnedCollection == nullptr) {
                 // Thinned container is not found, try looking recursively in thinned containers
                 // which were made by selecting elements from this thinned container.
                 edm::WrapperBase const* thinnedFromRecursiveCall = getThinnedProduct(thinnedCollectionPID, thinnedIndex, eventEntry);
                 if(thinnedFromRecursiveCall != nullptr) {
                     key = thinnedIndex;
                     return thinnedFromRecursiveCall;
                 } else {
                     continue;
                 }
             }
             key = thinnedIndex;
             return thinnedCollection;
         }
         return nullptr;
     }

void DataGetterHelper::getThinnedProducts	(	edm::ProductID const &	pid,
		std::vector< edm::WrapperBase const * > &	foundContainers,
		std::vector< unsigned int > &	keys,
		Long_t	eventEntry
	)		const

Definition at line 466 of file DataGetterHelper.cc.

References branchMap_, getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BranchID::isValid(), relval_steps::k, bookConverter::max, dbtoconf::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), and edm::ThinnedAssociation::thinnedCollectionID().

Referenced by fwlite::Event::getThinnedProducts().

                                                                        {
 
         edm::BranchID parent = branchMap_->productToBranchID(pid);
         if(!parent.isValid()) return;
         edm::ThinnedAssociationsHelper const& thinnedAssociationsHelper = branchMap_->thinnedAssociationsHelper();
 
         // Loop over thinned containers which were made by selecting elements from the parent container
         for(auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent),
                                iEnd = thinnedAssociationsHelper.parentEnd(parent);
             associatedBranches != iEnd; ++associatedBranches) {
 
             edm::ThinnedAssociation const* thinnedAssociation =
                 getThinnedAssociation(associatedBranches->association(), eventEntry);
             if(thinnedAssociation == nullptr) continue;
 
             if(associatedBranches->parent() != branchMap_->productToBranchID(thinnedAssociation->parentCollectionID())) {
               continue;
             }
 
             unsigned int nKeys = keys.size();
             unsigned int doNotLookForThisIndex = std::numeric_limits<unsigned int>::max();
             std::vector<unsigned int> thinnedIndexes(nKeys, doNotLookForThisIndex);
             bool hasAny = false;
             for(unsigned k = 0; k < nKeys; ++k) {
                 // Already found this one
                 if(foundContainers[k] != nullptr) continue;
                 // Already know this one is not in this thinned container
                 if(keys[k] == doNotLookForThisIndex ) continue;
                 // Does the thinned container hold the entry of interest?
                 // Modifies thinnedIndexes[k] only if it returns true and
                 // sets it to the index in the thinned collection.
                 if(thinnedAssociation->hasParentIndex(keys[k], thinnedIndexes[k])) {
                     hasAny = true;
                 }
             }
             if(!hasAny) {
                 continue;
             }
             // Get the thinned container and set the pointers and indexes into
             // it (if we can find it)
             edm::ProductID thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
             edm::WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID, eventEntry);
 
             if(thinnedCollection == nullptr) {
                 // Thinned container is not found, try looking recursively in thinned containers
                 // which were made by selecting elements from this thinned container.
                 getThinnedProducts(thinnedCollectionPID, foundContainers, thinnedIndexes, eventEntry);
                 for(unsigned k = 0; k < nKeys; ++k) {
                     if(foundContainers[k] == nullptr) continue;
                     if(thinnedIndexes[k] == doNotLookForThisIndex) continue;
                     keys[k] = thinnedIndexes[k];
                 }
             } else {
                 for(unsigned k = 0; k < nKeys; ++k) {
                     if(thinnedIndexes[k] == doNotLookForThisIndex) continue;
                     keys[k] = thinnedIndexes[k];
                     foundContainers[k] = thinnedCollection;
                 }
             }
         }
     }

const edm::ProcessHistory & DataGetterHelper::history ( ) const

private

Definition at line 550 of file DataGetterHelper.cc.

References historyGetter_.

Referenced by getBranchDataFor().

                                                              {
         return historyGetter_->history();
     }

const DataGetterHelper& fwlite::DataGetterHelper::operator= ( const DataGetterHelper & )

private

void fwlite::DataGetterHelper::setGetter ( std::shared_ptr< edm::EDProductGetter > getter )

inline

Definition at line 83 of file DataGetterHelper.h.

References getter(), and getter_.

Referenced by fwlite::Event::setGetter().

                                                                      {
                 getter_ = getter;
             }

edm::WrapperBase const * DataGetterHelper::wrapperBasePtr ( edm::ObjectWithDict const & objectWithDict ) const

private

Definition at line 412 of file DataGetterHelper.cc.

References edm::ObjectWithDict::address(), compareJSON::const, edm::TypeWithDict::pointerToBaseType(), and edm::ObjectWithDict::typeOf().

Referenced by getByBranchID(), and getByProductID().

                                                                                   {
         // This converts a void* that points at a Wrapper<T>* into a WrapperBase*
         edm::TypeWithDict wrapperBaseTypeWithDict(typeid(edm::WrapperBase));
         return static_cast<edm::WrapperBase const*>(wrapperBaseTypeWithDict.pointerToBaseType(objectWithDict.address(),
                                                                                               objectWithDict.typeOf()));
     }