#include <DataGetterHelper.h>

Public Member Functions
	DataGetterHelper (TTree *tree, boost::shared_ptr< HistoryGetterBase > historyGetter, boost::shared_ptr< BranchMapReader > branchMap=boost::shared_ptr< BranchMapReader >(), boost::shared_ptr< edm::EDProductGetter > getter=boost::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

virtual bool	getByLabel (std::type_info const &, char const , char const , char const *, edm::WrapperHolder &, Long_t) const

edm::WrapperHolder	getByProductID (edm::ProductID const &, Long_t) const

edm::EDProductGetter *	getter ()

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

virtual	~DataGetterHelper ()

Static Public Member Functions
static void	throwProductNotFoundException (std::type_info const &, char const , char const , char const *)

Private Types
typedef std::map < internal::DataKey, boost::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

const edm::ProcessHistory &	history () const

const DataGetterHelper &	operator= (const DataGetterHelper &)

Private Attributes
boost::shared_ptr < BranchMapReader >	branchMap_

KeyToDataMap	data_

boost::shared_ptr < edm::EDProductGetter >	getter_

boost::shared_ptr < fwlite::HistoryGetterBase >	historyGetter_

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

std::vector< char const * >	labels_

std::auto_ptr< TTreeCache >	tcache_

bool	tcTrained_

TTree *	tree_

Detailed Description

Definition at line 43 of file DataGetterHelper.h.

Member Typedef Documentation

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

private

Definition at line 88 of file DataGetterHelper.h.

Constructor & Destructor Documentation

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

Definition at line 62 of file DataGetterHelper.cc.

References branchMap_, edm::hlt::Exception, tcache_, MainPageGenerator::tree, tree_, and TTCACHE_SIZE.

                                                      :
         branchMap_(branchMap),
         historyGetter_(historyGetter),
         getter_(getter),
         tcache_(0),
         tcTrained_(false)
     {
         if(0==tree) {
             throw cms::Exception("NoTree")<<"The TTree pointer passed to the constructor was null";
         }
         tree_ = tree;
         if (useCache) {
             tree_->SetCacheSize(TTCACHE_SIZE);
             TFile* iFile(branchMap_->getFile());
             tcache_.reset(dynamic_cast<TTreeCache*>(iFile->GetCacheRead()));
             iFile->SetCacheRead(0);
             //std::cout << "In const " << iFile << " " << tcache_ << " " << iFile->GetCacheRead() << std::endl;
         }
     }

DataGetterHelper::~DataGetterHelper ( )

virtual

Definition at line 91 of file DataGetterHelper.cc.

91 { }

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

private

Member Function Documentation

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

private

Definition at line 130 of file DataGetterHelper.cc.

References fwlite::internal::Data::branch_, branchMap_, getHLTprescales::index, fwlite::internal::Data::lastProduct_, getGTfromDQMFile::obj, fwlite::internal::Data::obj_, fwlite::internal::Data::pObj_, fwlite::internal::Data::pProd_, tcache_, tcTrained_, and tree_.

Referenced by getByLabel(), and getByProductID().

     {
         GetterOperate op(iGetter);
 
         //WORK AROUND FOR ROOT!!
         //Create a new instance so that we can clear any cache the object uses
         //this slows the code down
         Reflex::Object obj = iData.obj_;
         iData.obj_ = iData.obj_.TypeOf().Construct();
         iData.pObj_ = iData.obj_.Address();
         iData.branch_->SetAddress(&(iData.pObj_));
         //If a REF to this was requested in the past, we might as well do the work now
         if(0!=iData.pProd_) {
             iData.pProd_ = iData.obj_.Address();
         }
         obj.Destruct();
         //END OF WORK AROUND
 
         if (0 == tcache_.get()) {
             iData.branch_->GetEntry(index);
         } else {
             if (!tcTrained_) {
                 tcache_->SetLearnEntries(100);
                 tcache_->SetEntryRange(0, tree_->GetEntries());
                 tcTrained_ = true;
             }
             withTCache tcguard(branchMap_->getFile(), tcache_.get());
             tree_->LoadTree(index);
             iData.branch_->GetEntry(index);
        }
        iData.lastProduct_=index;
     }

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

private

Definition at line 167 of file DataGetterHelper.cc.

References fwlite::branchNotFound, data_, edm::hlt::Exception, fwlite::findBranch(), edm::TypeID::friendlyClassName(), h, history(), fwlite::internal::DataKey::kEmpty(), combine::key, labels_, fwlite::internal::DataKey::module(), mergeVDriftHistosByStation::name, getGTfromDQMFile::obj, fwlite::internal::DataKey::process(), fwlite::internal::DataKey::product(), edm::ProcessHistory::rbegin(), edm::ProcessHistory::rend(), and tree_.

Referenced by getBranchNameFor(), and getByLabel().

     {
         edm::TypeID type(iInfo);
         internal::DataKey key(type, iModuleLabel, iProductInstanceLabel, iProcessLabel);
 
         boost::shared_ptr<internal::Data> theData;
         DataMap::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;
 
             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
 
                 //Use Reflex to create an instance of the object to be used as a buffer
                 Reflex::Type rType = Reflex::Type::ByTypeInfo(iInfo);
                 if(rType == Reflex::Type()) {
                     throw cms::Exception("UnknownType")<<"No Reflex dictionary exists for type "<<iInfo.name();
                 }
                 Reflex::Object obj = rType.Construct();
 
                 if(obj.Address() == 0) {
                     throw cms::Exception("ConstructionFailed")<<"failed to construct an instance of "<<rType.Name();
                 }
                 boost::shared_ptr<internal::Data> newData(new internal::Data());
                 newData->branch_ = branch;
                 newData->obj_ = obj;
                 newData->lastProduct_=-1;
                 newData->pObj_ = obj.Address();
                 newData->pProd_ = 0;
                 branch->SetAddress(&(newData->pObj_));
                 newData->interface_ = 0;
                 Reflex::Member getTheInterface = rType.FunctionMemberByName(std::string("getInterface"));
                 getTheInterface.Invoke(newData->interface_);
                 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 290 of file DataGetterHelper.cc.

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

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::getByLabel	(	std::type_info const &	iInfo,
		char const *	iModuleLabel,
		char const *	iProductInstanceLabel,
		char const *	iProcessLabel,
		void *	oData,
		Long_t	index
	)		const

virtual

Definition at line 305 of file DataGetterHelper.cc.

References fwlite::internal::Data::branch_, getBranchData(), getBranchDataFor(), getter_, getHLTprescales::index, fwlite::internal::Data::lastProduct_, and fwlite::internal::Data::obj_.

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

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

bool DataGetterHelper::getByLabel	(	std::type_info const &	iInfo,
		char const *	iModuleLabel,
		char const *	iProductInstanceLabel,
		char const *	iProcessLabel,
		edm::WrapperHolder &	holder,
		Long_t	index
	)		const

virtual

Definition at line 331 of file DataGetterHelper.cc.

References fwlite::internal::Data::branch_, getBranchData(), getBranchDataFor(), getter_, getHLTprescales::index, fwlite::internal::Data::interface_, edm::WrapperHolder::isValid(), fwlite::internal::Data::lastProduct_, and fwlite::internal::Data::obj_.

                                                                   {
 
         // Maintain atEnd() check in parent classes
 
         internal::Data& theData =
             DataGetterHelper::getBranchDataFor(iInfo, iModuleLabel, iProductInstanceLabel, iProcessLabel);
 
         if(0 != theData.branch_) {
             if(index != theData.lastProduct_) {
                 //haven't gotten the data for this event
                 getBranchData(getter_.get(), index, theData);
             }
         }
 
         holder = edm::WrapperHolder(theData.obj_.Address(), theData.interface_);
         return holder.isValid();
     }

edm::WrapperHolder DataGetterHelper::getByProductID	(	edm::ProductID const &	iID,
		Long_t	index
	)		const

Definition at line 354 of file DataGetterHelper.cc.

References edm::BranchDescription::branchID(), branchMap_, data_, edm::BranchDescription::fullClassName(), getBranchData(), getByLabel(), getter_, idToData_, getHLTprescales::index, edm::BranchID::isValid(), edm::WrapperHolder::isValid(), gen::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), edm::wrappedClassName(), and edm::WrapperHolder::wrapper().

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

     {
         typedef std::pair<edm::ProductID,edm::BranchListIndexes> IDPair;
         IDPair theID = std::make_pair(iID, branchMap_->branchListIndexes());
         std::map<IDPair,boost::shared_ptr<internal::Data> >::const_iterator itFound = idToData_.find(theID);
         if(itFound == idToData_.end()) {
             edm::BranchDescription const& bDesc = branchMap_->productToBranch(iID);
 
             if (!bDesc.branchID().isValid()) {
                 return edm::WrapperHolder();
             }
 
             //Calculate the key from the branch description
             Reflex::Type type(Reflex::Type::ByName(edm::wrappedClassName(bDesc.fullClassName())));
             assert(Reflex::Type() != 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(edm::TypeID(type.TypeInfo()),
                                 bDesc.moduleLabel().c_str(),
                                 pIL,
                                 bDesc.processName().c_str());
 
             //has this already been gotten?
             KeyToDataMap::iterator itData = data_.find(k);
             if(data_.end() == itData) {
                 //ask for the data
                 edm::WrapperHolder holder;
                 getByLabel(type.TypeInfo(),
                             k.module(),
                             k.product(),
                             k.process(),
                             holder, index);
                 if(!holder.isValid()) {
                     return holder;
                 }
                 itData = data_.find(k);
                 assert(itData != data_.end());
                 assert(holder.wrapper() == itData->second->obj_.Address());
             }
             itFound = idToData_.insert(std::make_pair(theID,itData->second)).first;
         }
         if(index != itFound->second->lastProduct_) {
             //haven't gotten the data for this event
             getBranchData(getter_.get(), index, *(itFound->second));
         }
         if(0==itFound->second->pProd_) {
             itFound->second->pProd_ = itFound->second->obj_.Address();
 
             if(0==itFound->second->pProd_) {
               return edm::WrapperHolder();
             }
         }
         //return itFound->second->pProd_;
         return edm::WrapperHolder(itFound->second->pProd_, itFound->second->interface_);
     }

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

inline

Definition at line 74 of file DataGetterHelper.h.

References getter_.

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

                                          {
                return getter_.get();
             }

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

private

Definition at line 414 of file DataGetterHelper.cc.

References historyGetter_.

Referenced by getBranchDataFor().

                                                              {
         return historyGetter_->history();
     }

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

private

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

inline

Definition at line 70 of file DataGetterHelper.h.

References getter(), and getter_.

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

                                                                        {
                 getter_ = getter;
             }

void DataGetterHelper::throwProductNotFoundException	(	std::type_info const &	iType,
		char const *	iModule,
		char const *	iProduct,
		char const *	iProcess
	)

static

Definition at line 423 of file DataGetterHelper.cc.

References edm::TypeID::className(), edm::hlt::Exception, and edm::errors::ProductNotFound.

     {
         edm::TypeID type(iType);
         throw edm::Exception(edm::errors::ProductNotFound)<<"A branch was found for \n  type ='"<<type.className()<<"'\n  module='"<<iModule
             <<"'\n  productInstance='"<<((0!=iProduct)?iProduct:"")<<"'\n  process='"<<((0!=iProcess)?iProcess:"")<<"'\n"
             "but no data is available for this Lumi";
     }