#include <EventPrincipal.h>

Inheritance diagram for edm::EventPrincipal:

Public Types
typedef EventAuxiliary	Auxiliary

typedef Principal	Base

typedef Base::SharedConstGroupPtr	SharedConstGroupPtr

Public Types inherited from edm::Principal
typedef std::vector< BasicHandle >	BasicHandleVec

typedef boost::filter_iterator < FilledGroupPtr, GroupCollection::const_iterator >	const_iterator

typedef std::vector < boost::shared_ptr< Group > >	GroupCollection

typedef std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef boost::shared_ptr < Group const >	SharedConstGroupPtr

typedef boost::shared_ptr< Group >	SharedGroupPtr

typedef GroupCollection::size_type	size_type

Public Member Functions
EventAuxiliary const &	aux () const

ProductID	branchIDToProductID (BranchID const &bid) const

BranchListIndexes const &	branchListIndexes () const

int const	bunchCrossing () const

void	clearEventPrincipal ()

	EventPrincipal (boost::shared_ptr< ProductRegistry const > reg, ProcessConfiguration const &pc)

EventSelectionIDVector const &	eventSelectionIDs () const

EventAuxiliary::ExperimentType	ExperimentType () const

void	fillEventPrincipal (std::auto_ptr< EventAuxiliary > aux, boost::shared_ptr< LuminosityBlockPrincipal > lbp, boost::shared_ptr< EventSelectionIDVector > eventSelectionIDs=boost::shared_ptr< EventSelectionIDVector >(new EventSelectionIDVector), boost::shared_ptr< BranchListIndexes > branchListIndexes=boost::shared_ptr< BranchListIndexes >(new BranchListIndexes), boost::shared_ptr< BranchMapper > mapper=boost::shared_ptr< BranchMapper >(new BranchMapper), boost::shared_ptr< DelayedReader > rtrv=boost::shared_ptr< DelayedReader >(new NoDelayedReader))

BasicHandle	getByProductID (ProductID const &oid) const

virtual EDProduct const *	getIt (ProductID const &pid) const

Provenance	getProvenance (ProductID const &pid) const

EventID const &	id () const

bool const	isReal () const

LuminosityBlockNumber_t	luminosityBlock () const

LuminosityBlockPrincipal const &	luminosityBlockPrincipal () const

LuminosityBlockPrincipal &	luminosityBlockPrincipal ()

void	put (ConstBranchDescription const &bd, std::auto_ptr< EDProduct > edp, std::auto_ptr< ProductProvenance > productProvenance)

void	putOnRead (ConstBranchDescription const &bd, std::auto_ptr< EDProduct > edp, std::auto_ptr< ProductProvenance > productProvenance)

RunNumber_t	run () const

RunPrincipal const &	runPrincipal () const

RunPrincipal &	runPrincipal ()

void	setUnscheduledHandler (boost::shared_ptr< UnscheduledHandler > iHandler)

int const	storeNumber () const

Timestamp const &	time () const

boost::shared_ptr < UnscheduledHandler >	unscheduledHandler () const

	~EventPrincipal ()

Public Member Functions inherited from edm::Principal
void	addGroupInput (boost::shared_ptr< ConstBranchDescription > bd)

void	addGroupScheduled (boost::shared_ptr< ConstBranchDescription > bd)

void	addGroupSource (boost::shared_ptr< ConstBranchDescription > bd)

void	addOnDemandGroup (boost::shared_ptr< ConstBranchDescription > bd)

void	adjustIndexesAfterProductRegistryAddition ()

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

const_iterator	begin () const

boost::shared_ptr< BranchMapper >	branchMapperPtr () const

BranchType const &	branchType () const

void	clearPrincipal ()

const_iterator	end () const

void	fillPrincipal (ProcessHistoryID const &hist, boost::shared_ptr< BranchMapper > mapper, boost::shared_ptr< DelayedReader > rtrv)

void	getAllProvenance (std::vector< Provenance const * > &provenances) const

BasicHandle	getByLabel (TypeID const &tid, std::string const &label, std::string const &productInstanceName, std::string const &processName, size_t &cachedOffset, int &fillCount) const

BasicHandle	getBySelector (TypeID const &tid, SelectorBase const &s) const

BasicHandle	getByType (TypeID const &tid) const

OutputHandle	getForOutput (BranchID const &bid, bool getProd) const

SharedConstGroupPtr const	getGroup (BranchID const &oid, bool resolveProd, bool fillOnDemand) const

void	getMany (TypeID const &tid, SelectorBase const &, BasicHandleVec &results) const

void	getManyByType (TypeID const &tid, BasicHandleVec &results) const

size_t	getMatchingSequence (TypeID const &typeID, SelectorBase const &selector, BasicHandle &result) const

Provenance	getProvenance (BranchID const &bid) const

void	maybeFlushCache (TypeID const &tid, InputTag const &tag) const

	Principal (boost::shared_ptr< ProductRegistry const > reg, ProcessConfiguration const &pc, BranchType bt)

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductRegistry const &	productRegistry () const

void	recombine (Principal &other, std::vector< BranchID > const &bids)

size_t	size () const

boost::shared_ptr< DelayedReader >	store () const

virtual	~Principal ()

Public Member Functions inherited from edm::EDProductGetter
	EDProductGetter ()

ProductID	oldToNewProductID (ProductID const &oldProductID) const

virtual	~EDProductGetter ()

Static Public Attributes
static int const	invalidBunchXing = EventAuxiliary::invalidBunchXing

static int const	invalidStoreNumber = EventAuxiliary::invalidStoreNumber

Private Member Functions
virtual ProductID	oldToNewProductID_ (ProductID const &oldProductID) const

BranchID	pidToBid (ProductID const &pid) const

virtual void	resolveProduct_ (Group const &g, bool fillOnDemand) const

virtual bool	unscheduledFill (std::string const &moduleLabel) const

Private Attributes
boost::scoped_ptr< EventAuxiliary >	aux_

boost::shared_ptr < BranchListIndexes >	branchListIndexes_

std::map< BranchListIndex, ProcessIndex >	branchListIndexToProcessIndex_

boost::shared_ptr < EventSelectionIDVector >	eventSelectionIDs_

boost::shared_ptr < LuminosityBlockPrincipal >	luminosityBlockPrincipal_

std::vector< std::string >	moduleLabelsRunning_

boost::shared_ptr < UnscheduledHandler >	unscheduledHandler_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProductGetter
static void	assignEDProductGetter (EDProductGetter const *&)

static EDProductGetter const *	switchProductGetter (EDProductGetter const *)
	These can only be used internally by the framework. More...

Protected Member Functions inherited from edm::Principal
void	addGroup_ (std::auto_ptr< Group > g)

void	addGroupOrThrow (std::auto_ptr< Group > g)

void	checkUniquenessAndType (std::auto_ptr< EDProduct > &prod, Group const *group) const

Group *	getExistingGroup (BranchID const &branchID)

Group *	getExistingGroup (Group const &g)

SharedConstGroupPtr const	getGroupByIndex (ProductTransientIndex const &oid, bool resolveProd, bool fillOnDemand) const

ProcessHistory &	processHistoryUpdate ()

void	putOrMerge (std::auto_ptr< EDProduct > prod, Group const *group) const

void	putOrMerge (std::auto_ptr< EDProduct > prod, std::auto_ptr< ProductProvenance > prov, Group *group)

void	resolveProduct (Group const &g, bool fillOnDemand) const

void	setProcessHistory (Principal const &principal)

void	swapBase (Principal &)

Detailed Description

Definition at line 36 of file EventPrincipal.h.

Member Typedef Documentation

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 38 of file EventPrincipal.h.

typedef Principal edm::EventPrincipal::Base

Definition at line 39 of file EventPrincipal.h.

typedef Base::SharedConstGroupPtr edm::EventPrincipal::SharedConstGroupPtr

Definition at line 41 of file EventPrincipal.h.

Constructor & Destructor Documentation

edm::EventPrincipal::EventPrincipal	(	boost::shared_ptr< ProductRegistry const >	reg,
		ProcessConfiguration const &	pc
	)

Definition at line 19 of file EventPrincipal.cc.

                                         :
           Base(reg, pc, InEvent),
           aux_(),
           luminosityBlockPrincipal_(),
           unscheduledHandler_(),
           moduleLabelsRunning_(),
           eventSelectionIDs_(),
           branchListIndexes_(),
           branchListIndexToProcessIndex_() {}

edm::EventPrincipal::~EventPrincipal ( )

inline

Definition at line 47 of file EventPrincipal.h.

47 {}

Member Function Documentation

EventAuxiliary const& edm::EventPrincipal::aux ( ) const

inline

Definition at line 90 of file EventPrincipal.h.

References aux_.

Referenced by bunchCrossing(), ExperimentType(), id(), isReal(), edm::isSameEvent(), edm::StreamSerializer::serializeEvent(), storeNumber(), time(), edm::SubProcess::write(), and edm::RootOutputFile::writeOne().

                                       {
       return *aux_;
     }

ProductID edm::EventPrincipal::branchIDToProductID ( BranchID const & bid ) const

Definition at line 161 of file EventPrincipal.cc.

References branchListIndexToProcessIndex_, edm::hlt::Exception, edm::detail::ThreadSafeIndexedRegistry< T, E >::extra(), i, edm::detail::ThreadSafeIndexedRegistry< T, E >::instance(), edm::BranchID::isValid(), and edm::errors::NotFound.

Referenced by fillEventPrincipal(), edm::Event::makeProductID(), and oldToNewProductID_().

                                                                {
     if(!bid.isValid()) {
       throw Exception(errors::NotFound, "InvalidID")
         << "branchIDToProductID: invalid BranchID supplied\n";
     }
     typedef BranchIDListHelper::BranchIDToIndexMap BIDToIndexMap;
     typedef BIDToIndexMap::const_iterator Iter;
     typedef std::pair<Iter, Iter> IndexRange;
 
     BIDToIndexMap const& branchIDToIndexMap = BranchIDListRegistry::instance()->extra().branchIDToIndexMap();
     IndexRange range = branchIDToIndexMap.equal_range(bid);
     for(Iter it = range.first; it != range.second; ++it) {
       BranchListIndex blix = it->second.first;
       std::map<BranchListIndex, ProcessIndex>::const_iterator i = branchListIndexToProcessIndex_.find(blix);
       if(i != branchListIndexToProcessIndex_.end()) {
         ProductIndex productIndex = it->second.second;
         ProcessIndex processIndex = i->second;
         return ProductID(processIndex+1, productIndex+1);
       }
     }
     // cannot throw, because some products may legitimately not have product ID's (e.g. pile-up).
     return ProductID();
   }

BranchListIndexes const & edm::EventPrincipal::branchListIndexes ( ) const

Definition at line 235 of file EventPrincipal.cc.

References branchListIndexes_.

Referenced by fillEventPrincipal(), edm::StreamSerializer::serializeEvent(), and edm::RootOutputFile::writeOne().

                                           {
     return *branchListIndexes_;
   }

int const edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 82 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::bunchCrossing().

                                     {
       return aux().bunchCrossing();
     }

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 32 of file EventPrincipal.cc.

References aux_, branchListIndexes_, branchListIndexToProcessIndex_, edm::Principal::clearPrincipal(), eventSelectionIDs_, luminosityBlockPrincipal_, moduleLabelsRunning_, and unscheduledHandler_.

Referenced by edm::EventProcessor::readAndProcessEvent().

                                       {
     clearPrincipal();
     aux_.reset();
     luminosityBlockPrincipal_.reset();
     unscheduledHandler_.reset();
     moduleLabelsRunning_.clear();
     eventSelectionIDs_.reset();
     branchListIndexes_.reset();
     branchListIndexToProcessIndex_.clear();
   }

EventSelectionIDVector const & edm::EventPrincipal::eventSelectionIDs ( ) const

Definition at line 230 of file EventPrincipal.cc.

References eventSelectionIDs_.

Referenced by edm::Event::eventSelectionIDs(), fillEventPrincipal(), edm::StreamSerializer::serializeEvent(), and edm::RootOutputFile::writeOne().

                                           {
     return *eventSelectionIDs_;
   }

EventAuxiliary::ExperimentType edm::EventPrincipal::ExperimentType ( ) const

inline

Definition at line 78 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::experimentType().

                                                         {
       return aux().experimentType();
     }

void edm::EventPrincipal::fillEventPrincipal	(	std::auto_ptr< EventAuxiliary >	aux,
		boost::shared_ptr< LuminosityBlockPrincipal >	lbp,
		boost::shared_ptr< EventSelectionIDVector >	eventSelectionIDs = `boost::shared_ptr<EventSelectionIDVector>(new EventSelectionIDVector)`,
		boost::shared_ptr< BranchListIndexes >	branchListIndexes = `boost::shared_ptr<BranchListIndexes>(new BranchListIndexes)`,
		boost::shared_ptr< BranchMapper >	mapper = `boost::shared_ptr<BranchMapper>(new BranchMapper)`,
		boost::shared_ptr< DelayedReader >	rtrv = `boost::shared_ptr<DelayedReader>(new NoDelayedReader)`
	)

Definition at line 44 of file EventPrincipal.cc.

References aux_, edm::Principal::begin(), branchIDToProductID(), branchListIndexes(), branchListIndexes_, branchListIndexToProcessIndex_, edm::Principal::end(), eventSelectionIDs(), eventSelectionIDs_, edm::Principal::fillPrincipal(), edm::BranchIDListHelper::fixBranchListIndexes(), edm::InEvent, luminosityBlockPrincipal_, edm::Principal::processHistoryID(), edm::Principal::productRegistry(), and edm::Principal::setProcessHistory().

Referenced by edm::StreamerInputSource::deserializeEvent(), edm::DaqSource::getNextItemType(), edm::RawInputSource::makeEvent(), edm::RootFile::readCurrentEvent(), edm::ConfigurableInputSource::reallyReadEvent(), and edm::SubProcess::write().

                                              {
     fillPrincipal(aux->processHistoryID(), mapper, rtrv);
     aux_.reset(aux.release());
     luminosityBlockPrincipal_ = lbp;
     eventSelectionIDs_ = eventSelectionIDs;
     branchListIndexes_ = branchListIndexes;
 
     if(luminosityBlockPrincipal_) {
       setProcessHistory(*luminosityBlockPrincipal_);
       aux_->setProcessHistoryID(processHistoryID());
     }
 
     mapper->processHistoryID() = processHistoryID();
     BranchIDListHelper::fixBranchListIndexes(*branchListIndexes_);
 
     if(productRegistry().productProduced(InEvent)) {
       // Add index into BranchIDListRegistry for products produced this process
       branchListIndexes_->push_back(productRegistry().producedBranchListIndex());
     }
 
     // Fill in helper map for Branch to ProductID mapping
     for(BranchListIndexes::const_iterator
         it = branchListIndexes_->begin(),
         itEnd = branchListIndexes_->end();
         it != itEnd; ++it) {
       ProcessIndex pix = it - branchListIndexes_->begin();
       branchListIndexToProcessIndex_.insert(std::make_pair(*it, pix));
     }
     // Fill in the product ID's in the groups.
     for(const_iterator it = this->begin(), itEnd = this->end(); it != itEnd; ++it) {
       (*it)->setProvenance(mapper, branchIDToProductID((*it)->branchDescription().branchID()));
     }
   }

BasicHandle edm::EventPrincipal::getByProductID ( ProductID const & oid ) const

Definition at line 186 of file EventPrincipal.cc.

References edm::hlt::Exception, g, edm::Principal::getGroup(), pidToBid(), and edm::errors::ProductNotFound.

Referenced by edm::Event::getByProductID_(), and getIt().

                                                            {
     BranchID bid = pidToBid(pid);
     SharedConstGroupPtr const& g = getGroup(bid, true, true);
     if(g.get() == 0) {
       boost::shared_ptr<cms::Exception> whyFailed(new Exception(errors::ProductNotFound, "InvalidID"));
       *whyFailed
         << "get by product ID: no product with given id: " << pid << "\n";
       return BasicHandle(whyFailed);
     }
 
     // Check for case where we tried on demand production and
     // it failed to produce the object
     if(g->onDemand()) {
       boost::shared_ptr<cms::Exception> whyFailed(new Exception(errors::ProductNotFound, "InvalidID"));
       *whyFailed
         << "get by product ID: no product with given id: " << pid << "\n"
         << "onDemand production failed to produce it.\n";
       return BasicHandle(whyFailed);
     }
     return BasicHandle(g->product(), g->provenance());
   }

EDProduct const * edm::EventPrincipal::getIt ( ProductID const & pid ) const

virtual

Reimplemented from edm::Principal.

Definition at line 209 of file EventPrincipal.cc.

References getByProductID(), and edm::BasicHandle::wrapper().

                                                   {
     return getByProductID(pid).wrapper();
   }

Provenance edm::EventPrincipal::getProvenance ( ProductID const & pid ) const

Definition at line 214 of file EventPrincipal.cc.

References pidToBid().

Referenced by edm::Event::getProvenance().

                                                           {
     BranchID bid = pidToBid(pid);
     return getProvenance(bid);
   }

EventID const& edm::EventPrincipal::id ( void ) const

inline

Definition at line 66 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::id().

                               {
       return aux().id();
     }

bool const edm::EventPrincipal::isReal ( ) const

inline

Definition at line 74 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::isRealData().

                               {
       return aux().isRealData();
     }

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 94 of file EventPrincipal.h.

References id(), and edm::EventID::luminosityBlock().

Referenced by Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), edm::InputSource::readEvent(), edm::PoolSource::readEvent_(), and edm::StreamerOutputModuleBase::serializeEvent().

                                                     {
       return id().luminosityBlock();
     }

LuminosityBlockPrincipal const& edm::EventPrincipal::luminosityBlockPrincipal ( ) const

inline

Definition at line 58 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

Referenced by runPrincipal().

                                                                      {
       return *luminosityBlockPrincipal_;
     }

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 62 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                                          {
       return *luminosityBlockPrincipal_;
     }

ProductID edm::EventPrincipal::oldToNewProductID_ ( ProductID const & oldProductID ) const

privatevirtual

Reimplemented from edm::EDProductGetter.

Definition at line 270 of file EventPrincipal.cc.

References branchIDToProductID(), edm::Principal::branchMapperPtr(), and edm::BranchID::isValid().

                                                                         {
     BranchID bid = branchMapperPtr()->oldProductIDToBranchID(oldProductID);
     if(!bid.isValid()) return oldProductID;
     return branchIDToProductID(bid);
   }

BranchID edm::EventPrincipal::pidToBid ( ProductID const & pid ) const

private

Definition at line 152 of file EventPrincipal.cc.

References branchListIndexes_, runTheMatrix::data, edm::hlt::Exception, edm::detail::ThreadSafeIndexedRegistry< T, E >::instance(), edm::ProductID::isValid(), edm::productIDToBranchID(), and edm::errors::ProductNotFound.

Referenced by getByProductID(), and getProvenance().

                                                      {
     if(!pid.isValid()) {
       throw Exception(errors::ProductNotFound, "InvalidID")
         << "get by product ID: invalid ProductID supplied\n";
     }
     return productIDToBranchID(pid, BranchIDListRegistry::instance()->data(), *branchListIndexes_);
   }

void edm::EventPrincipal::put	(	ConstBranchDescription const &	bd,
		std::auto_ptr< EDProduct >	edp,
		std::auto_ptr< ProductProvenance >	productProvenance
	)

Definition at line 94 of file EventPrincipal.cc.

References edm::ConstBranchDescription::branchID(), edm::Principal::branchMapperPtr(), edm::Principal::checkUniquenessAndType(), edm::hlt::Exception, g, edm::Principal::getExistingGroup(), edm::errors::InsertFailure, edm::ConstBranchDescription::produced(), and edm::Group::putProduct().

Referenced by edm::Event::commit_aux().

                                                           {
 
     assert(bd.produced());
     if(edp.get() == 0) {
       throw Exception(errors::InsertFailure, "Null Pointer")
         << "put: Cannot put because auto_ptr to product is null."
         << "\n";
     }
     branchMapperPtr()->insert(*productProvenance);
     Group *g = getExistingGroup(bd.branchID());
     assert(g);
     checkUniquenessAndType(edp, g);
     // Group assumes ownership
     g->putProduct(edp, productProvenance);
   }

void edm::EventPrincipal::putOnRead	(	ConstBranchDescription const &	bd,
		std::auto_ptr< EDProduct >	edp,
		std::auto_ptr< ProductProvenance >	productProvenance
	)

Definition at line 114 of file EventPrincipal.cc.

References edm::ConstBranchDescription::branchID(), edm::Principal::branchMapperPtr(), edm::Principal::checkUniquenessAndType(), g, edm::Principal::getExistingGroup(), edm::ConstBranchDescription::produced(), and edm::Group::putProduct().

Referenced by edm::StreamerInputSource::deserializeEvent().

                                                           {
 
     assert(!bd.produced());
     branchMapperPtr()->insert(*productProvenance);
     Group *g = getExistingGroup(bd.branchID());
     assert(g);
     checkUniquenessAndType(edp, g);
     // Group assumes ownership
     g->putProduct(edp, productProvenance);
   }

void edm::EventPrincipal::resolveProduct_	(	Group const &	g,
		bool	fillOnDemand
	)		const

privatevirtual

Reimplemented from edm::Principal.

Definition at line 129 of file EventPrincipal.cc.

References edm::Group::branchDescription(), edm::Principal::checkUniquenessAndType(), edm::getProduct(), edm::ConstBranchDescription::moduleLabel(), edm::Group::onDemand(), edm::ConstBranchDescription::produced(), edm::Group::product(), edm::Group::productUnavailable(), edm::Group::putProduct(), edm::Principal::store(), and unscheduledFill().

                                                                          {
     // Try unscheduled production.
     if(g.onDemand()) {
       if(fillOnDemand) {
         unscheduledFill(g.branchDescription().moduleLabel());
       }
       return;
     }
 
     if(g.branchDescription().produced()) return; // nothing to do.
     if(g.product()) return; // nothing to do.
     if(g.productUnavailable()) return; // nothing to do.
 
     // must attempt to load from persistent store
     BranchKey const bk = BranchKey(g.branchDescription());
     std::auto_ptr<EDProduct> edp(store()->getProduct(bk, this));
 
     // Now fix up the Group
     checkUniquenessAndType(edp, &g);
     g.putProduct(edp);
   }

RunNumber_t edm::EventPrincipal::run ( void ) const

inline

Definition at line 98 of file EventPrincipal.h.

References id(), and edm::EventID::run().

Referenced by Types.LuminosityBlockID::cppID(), edm::InputSource::readEvent(), and edm::PoolSource::readEvent_().

                             {
       return id().run();
     }

RunPrincipal const & edm::EventPrincipal::runPrincipal ( ) const

Definition at line 84 of file EventPrincipal.cc.

References luminosityBlockPrincipal(), and edm::LuminosityBlockPrincipal::runPrincipal().

                                      {
     return luminosityBlockPrincipal().runPrincipal();
   }

RunPrincipal & edm::EventPrincipal::runPrincipal ( )

Definition at line 89 of file EventPrincipal.cc.

References luminosityBlockPrincipal(), and edm::LuminosityBlockPrincipal::runPrincipal().

                                {
     return luminosityBlockPrincipal().runPrincipal();
   }

void edm::EventPrincipal::setUnscheduledHandler ( boost::shared_ptr< UnscheduledHandler > iHandler )

Definition at line 220 of file EventPrincipal.cc.

References unscheduledHandler_.

Referenced by edm::Schedule::setupOnDemandSystem().

                                                                                     {
     unscheduledHandler_ = iHandler;
   }

int const edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 86 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::storeNumber().

                                   {
       return aux().storeNumber();
     }

Timestamp const& edm::EventPrincipal::time ( ) const

inline

Definition at line 70 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::time().

Referenced by edm::OccurrenceTraits< EventPrincipal, BranchActionBegin >::preScheduleSignal(), edm::EventProcessor::readAndProcessEvent(), edm::InputSource::readEvent(), and edm::AsciiOutputModule::write().

                                   {
       return aux().time();
     }

bool edm::EventPrincipal::unscheduledFill ( std::string const & moduleLabel ) const

privatevirtual

Implements edm::Principal.

Definition at line 240 of file EventPrincipal.cc.

References edm::hlt::Exception, edm::find_in_all(), i, edm::errors::LogicError, moduleLabelsRunning_, and unscheduledHandler_.

Referenced by resolveProduct_().

                                                                     {
 
     // If it is a module already currently running in unscheduled
     // mode, then there is a circular dependency related to which
     // EDProducts modules require and produce.  There is no safe way
     // to recover from this.  Here we check for this problem and throw
     // an exception.
     std::vector<std::string>::const_iterator i =
       find_in_all(moduleLabelsRunning_, moduleLabel);
 
     if(i != moduleLabelsRunning_.end()) {
       throw Exception(errors::LogicError)
         << "Hit circular dependency while trying to run an unscheduled module.\n"
         << "Current implementation of unscheduled execution cannot always determine\n"
         << "the proper order for module execution.  It is also possible the modules\n"
         << "have a built in circular dependence that will not work with any order.\n"
         << "In the first case, scheduling some or all required modules in paths will help.\n"
         << "In the second case, the modules themselves will have to be fixed.\n";
     }
 
     moduleLabelsRunning_.push_back(moduleLabel);
 
     if(unscheduledHandler_) {
       unscheduledHandler_->tryToFill(moduleLabel, *const_cast<EventPrincipal *>(this));
     }
     moduleLabelsRunning_.pop_back();
     return true;
   }

boost::shared_ptr< UnscheduledHandler > edm::EventPrincipal::unscheduledHandler ( ) const

Definition at line 225 of file EventPrincipal.cc.

References unscheduledHandler_.

Referenced by edm::WorkerT< T >::implDoBegin().

                                            {
      return unscheduledHandler_;
   }

Member Data Documentation

boost::scoped_ptr<EventAuxiliary> edm::EventPrincipal::aux_

private

Definition at line 147 of file EventPrincipal.h.

Referenced by aux(), clearEventPrincipal(), and fillEventPrincipal().

boost::shared_ptr<BranchListIndexes> edm::EventPrincipal::branchListIndexes_

private

Definition at line 158 of file EventPrincipal.h.

Referenced by branchListIndexes(), clearEventPrincipal(), fillEventPrincipal(), and pidToBid().

std::map<BranchListIndex, ProcessIndex> edm::EventPrincipal::branchListIndexToProcessIndex_

private

Definition at line 160 of file EventPrincipal.h.

Referenced by branchIDToProductID(), clearEventPrincipal(), and fillEventPrincipal().

boost::shared_ptr<EventSelectionIDVector> edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 156 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), eventSelectionIDs(), and fillEventPrincipal().

int const edm::EventPrincipal::invalidBunchXing = EventAuxiliary::invalidBunchXing

static

Definition at line 42 of file EventPrincipal.h.

int const edm::EventPrincipal::invalidStoreNumber = EventAuxiliary::invalidStoreNumber

static

Definition at line 43 of file EventPrincipal.h.

boost::shared_ptr<LuminosityBlockPrincipal> edm::EventPrincipal::luminosityBlockPrincipal_

private

Definition at line 149 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), fillEventPrincipal(), and luminosityBlockPrincipal().

std::vector<std::string> edm::EventPrincipal::moduleLabelsRunning_

mutableprivate

Definition at line 154 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), and unscheduledFill().

boost::shared_ptr<UnscheduledHandler> edm::EventPrincipal::unscheduledHandler_

private

Definition at line 152 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), setUnscheduledHandler(), unscheduledFill(), and unscheduledHandler().

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation