#include "Principal.h"

Inheritance diagram for art::Principal:

Public Types
using	GroupCollection = std::map< ProductID, std::unique_ptr< Group >>

using	const_iterator = GroupCollection::const_iterator

using	ProcessNameConstIterator = ProcessHistory::const_iterator

using	GroupQueryResultVec = std::vector< GroupQueryResult >

using	size_type = GroupCollection::size_type

using	ProcessName = std::string

Public Member Functions
virtual	~Principal () noexcept=default

	Principal (Principal const &)=delete

Principal &	operator= (Principal const &)=delete

	Principal (ProcessConfiguration const &, ProcessHistoryID const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< BranchMapper > &&, std::unique_ptr< DelayedReader > &&)

EDProductGetter const *	productGetter (ProductID const pid) const

OutputHandle	getForOutput (ProductID const, bool resolveProd) const

GroupQueryResult	getBySelector (WrappedTypeID const &wrapped, SelectorBase const &) const

GroupQueryResult	getByProductID (ProductID const pid) const

GroupQueryResult	getByLabel (WrappedTypeID const &wrapped, std::string const &label, std::string const &productInstanceName, std::string const &processName) const

GroupQueryResultVec	getMany (WrappedTypeID const &wrapped, SelectorBase const &) const

GroupQueryResultVec	getMatchingSequence (SelectorBase const &) const

void	removeCachedProduct (ProductID const pid) const

void	addSecondaryPrincipal (std::unique_ptr< Principal > &&val)

void	setProducedProducts (ProductTable const &producedProducts)

void	readImmediate () const

void	readProvenanceImmediate () const

ProcessHistory const &	processHistory () const

ProcessConfiguration const &	processConfiguration () const

BranchMapper const &	branchMapper () const

size_t	size () const

const_iterator	begin () const

const_iterator	cbegin () const

const_iterator	end () const

const_iterator	cend () const

void	addToProcessHistory ()

virtual BranchType	branchType () const =0

virtual void	fillGroup (BranchDescription const &)=0

virtual RangeSet	seenRanges () const =0

EDProductGetter const *	getEDProductGetter (ProductID const pid) const

Protected Member Functions
BranchMapper &	branchMapper ()

DelayedReader &	productReader ()

void	fillGroup (std::unique_ptr< Group > &&group)

int	tryNextSecondaryFile () const

cet::exempt_ptr< Group const >	getGroupForPtr (ProductID const pid) const

cet::exempt_ptr< Group const >	getGroup (ProductID const pid) const

cet::exempt_ptr< Group const >	getResolvedGroup (ProductID const pid, bool resolveProd) const

Private Member Functions
virtual ProcessHistoryID const &	processHistoryID () const =0

virtual void	setProcessHistoryID (ProcessHistoryID const &)=0

GroupQueryResultVec	matchingSequenceFromInputFile (SelectorBase const &) const

GroupQueryResultVec	findGroupsForProduct (WrappedTypeID const &wrapped, SelectorBase const &, bool stopIfProcessHasMatch) const

size_t	findGroupsFromInputFile (WrappedTypeID const &wrapped, SelectorBase const &, GroupQueryResultVec &results, bool stopIfProcessHasMatch) const

size_t	findGroups (ProcessLookup const &, SelectorBase const &, GroupQueryResultVec &results, bool stopIfProcessHasMatch, TypeID wanted_wrapper=TypeID{}) const

size_t	findGroupsForProcess (std::vector< ProductID > const &vpid, SelectorBase const &selector, GroupQueryResultVec &results, TypeID wanted_wrapper) const

bool	presentFromSource (ProductID) const

EDProductGetter const *	deferredGetter_ (ProductID const pid) const

EDProductGetter const *	getEDProductGetterImpl (ProductID const pid) const final override

Private Attributes
ProcessHistory	processHistory_ {}

ProcessConfiguration const &	processConfiguration_

cet::exempt_ptr< ProductTable const >	presentProducts_

cet::exempt_ptr< ProductTable const >	producedProducts_ {nullptr}

std::map< ProductID, std::shared_ptr< DeferredProductGetter const > >	deferredGetters_ {}

bool	processHistoryModified_ {false}

GroupCollection	groups_ {}

std::unique_ptr< BranchMapper >	branchMapperPtr_

std::unique_ptr< DelayedReader >	store_

std::vector< std::unique_ptr< Principal > >	secondaryPrincipals_ {}

int	nextSecondaryFileIdx_ {}

Detailed Description

Definition at line 48 of file Principal.h.

Member Typedef Documentation

using art::Principal::const_iterator = GroupCollection::const_iterator

Definition at line 52 of file Principal.h.

using art::Principal::GroupCollection = std::map<ProductID, std::unique_ptr<Group>>

Definition at line 51 of file Principal.h.

using art::Principal::GroupQueryResultVec = std::vector<GroupQueryResult>

Definition at line 54 of file Principal.h.

using art::Principal::ProcessName = std::string

Definition at line 56 of file Principal.h.

using art::Principal::ProcessNameConstIterator = ProcessHistory::const_iterator

Definition at line 53 of file Principal.h.

using art::Principal::size_type = GroupCollection::size_type

Definition at line 55 of file Principal.h.

Constructor & Destructor Documentation

virtual art::Principal::~Principal ( )

virtualdefaultnoexcept

art::Principal::Principal ( Principal const & )

delete

Principal::Principal	(	ProcessConfiguration const &	pc,
		ProcessHistoryID const &	hist,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< BranchMapper > &&	mapper,
		std::unique_ptr< DelayedReader > &&	reader
	)

Definition at line 59 of file Principal.cc.

References branchMapperPtr_, art::thread_safe_registry_via_id< K, M >::empty(), art::thread_safe_registry_via_id< K, M >::get(), hist, presentProducts_, processHistory_, store_, and std::swap().

   : processConfiguration_{pc}
   , presentProducts_{presentProducts}
   , branchMapperPtr_{std::move(mapper)}
   , store_{std::move(reader)}
 {
   if (!hist.isValid()) {
     return;
   }
   assert(!ProcessHistoryRegistry::empty());
   ProcessHistory ph;
   bool const found[[gnu::unused]]{ProcessHistoryRegistry::get(hist, ph)};
   assert(found);
   std::swap(processHistory_, ph);
 }

Member Function Documentation

void art::Principal::addSecondaryPrincipal ( std::unique_ptr< Principal > && val )

inline

Definition at line 100 of file Principal.h.

References secondaryPrincipals_.

     {
       secondaryPrincipals_.emplace_back(std::move(val));
     }

void Principal::addToProcessHistory ( )

Definition at line 80 of file Principal.cc.

References art::errors::Configuration, art::thread_safe_registry_via_id< K, M >::emplace(), processConfiguration_, processHistory_, processHistoryModified_, art::ProcessConfiguration::processName(), and setProcessHistoryID().

Referenced by cend(), art::EventPrincipal::EventPrincipal(), art::RunPrincipal::RunPrincipal(), art::SubRunPrincipal::SubRunPrincipal(), art::RootOutput::write(), art::RootOutput::writeRun(), and art::RootOutput::writeSubRun().

 {
   if (processHistoryModified_) {
     return;
   }
   string const& processName = processConfiguration_.processName();
   for (auto const& val : processHistory_) {
     if (processName == val.processName()) {
       throw art::Exception(errors::Configuration)
         << "The process name " << processName
         << " was previously used on these products.\n"
         << "Please modify the configuration file to use a "
         << "distinct process name.\n";
     }
   }
   processHistory_.push_back(processConfiguration_);
   // OPTIMIZATION NOTE: As of 0_9_0_pre3 For very simple Sources
   // (e.g. EmptyEvent) this routine takes up nearly 50% of the time
   // per event, and 96% of the time for this routine is spent in
   // computing the ProcessHistory id which happens because we are
   // reconstructing the ProcessHistory for each event.  It would
   // probably be better to move the ProcessHistory construction out to
   // somewhere which persists for longer than one Event.
   auto const phid = processHistory_.id();
   ProcessHistoryRegistry::emplace(phid, processHistory_);
   setProcessHistoryID(phid);
   processHistoryModified_ = true;
 }

const_iterator art::Principal::begin ( ) const

inline

Definition at line 156 of file Principal.h.

References groups_.

     {
       return groups_.begin();
     }

BranchMapper const& art::Principal::branchMapper ( ) const

inline

Definition at line 144 of file Principal.h.

References branchMapperPtr_.

Referenced by fillGroup(), art::detail::KeptProvenance::insertAncestors(), art::ResultsPrincipal::put(), art::RunPrincipal::put(), art::SubRunPrincipal::put(), and art::EventPrincipal::put().

     {
       return *branchMapperPtr_;
     }

BranchMapper& art::Principal::branchMapper ( )

inlineprotected

Definition at line 192 of file Principal.h.

References branchMapperPtr_.

     {
       return *branchMapperPtr_;
     }

virtual BranchType art::Principal::branchType ( ) const

pure virtual

Implemented in art::EventPrincipal, art::SubRunPrincipal, art::RunPrincipal, and art::ResultsPrincipal.

Referenced by cend(), art::get_ProductDescription(), and art::SourceHelper::makePtr().

const_iterator art::Principal::cbegin ( ) const

inline

Definition at line 162 of file Principal.h.

References groups_.

     {
       return groups_.cbegin();
     }

const_iterator art::Principal::cend ( ) const

inline

Definition at line 174 of file Principal.h.

References addToProcessHistory(), branchType(), fillGroup(), groups_, and seenRanges().

     {
       return groups_.cend();
     }

EDProductGetter const * Principal::deferredGetter_ ( ProductID const pid ) const

private

Definition at line 412 of file Principal.cc.

References deferredGetters_.

Referenced by fillGroup(), and productGetter().

 {
   auto it = deferredGetters_.find(pid);
   if (it != deferredGetters_.end()) {
     return it->second.get();
   }
   deferredGetters_[pid] = std::make_shared<DeferredProductGetter>(
     cet::exempt_ptr<Principal const>{this}, pid);
   return deferredGetters_[pid].get();
 }

const_iterator art::Principal::end ( void ) const

inline

Definition at line 168 of file Principal.h.

References groups_.

     {
       return groups_.end();
     }

virtual void art::Principal::fillGroup ( BranchDescription const & )

pure virtual

Implemented in art::EventPrincipal, art::SubRunPrincipal, art::RunPrincipal, and art::ResultsPrincipal.

Referenced by cend(), art::ResultsPrincipal::fillGroup(), art::RunPrincipal::fillGroup(), art::SubRunPrincipal::fillGroup(), art::EventPrincipal::fillGroup(), art::RootInputTree::fillGroups(), art::ResultsPrincipal::put(), art::RunPrincipal::put(), art::SubRunPrincipal::put(), and art::EventPrincipal::put().

void art::Principal::fillGroup ( std::unique_ptr< Group > && group )

inlineprotected

Definition at line 205 of file Principal.h.

References branchMapper(), deferredGetter_(), findGroups(), findGroupsForProcess(), findGroupsForProduct(), findGroupsFromInputFile(), art::BranchDescription::friendlyClassName(), getGroup(), getGroupForPtr(), getResolvedGroup(), groups_, matchingSequenceFromInputFile(), art::BranchDescription::moduleLabel(), presentFromSource(), processHistoryID(), art::BranchDescription::processName(), art::BranchDescription::producedClassName(), art::BranchDescription::productID(), setProcessHistoryID(), store_, and tryNextSecondaryFile().

     {
       BranchDescription const& pd = group->productDescription();
       assert(!pd.producedClassName().empty());
       assert(!pd.friendlyClassName().empty());
       assert(!pd.moduleLabel().empty());
       assert(!pd.processName().empty());
       group->setResolvers(branchMapper(), *store_);
       groups_[pd.productID()] = std::move(group);
     }

std::size_t Principal::findGroups	(	ProcessLookup const &	pl,
		SelectorBase const &	sel,
		GroupQueryResultVec &	results,
		bool	stopIfProcessHasMatch,
		TypeID	wanted_wrapper = `TypeID{}`
	)		const

private

Definition at line 355 of file Principal.cc.

References findGroupsForProcess(), and processHistory().

Referenced by fillGroup(), findGroupsForProduct(), findGroupsFromInputFile(), getMatchingSequence(), and matchingSequenceFromInputFile().

 {
   // Loop over processes in reverse time order.  Sometimes we want to
   // stop after we find a process with matches so check for that at
   // each step.
   std::size_t found{};
   for (auto const& h : reverse_iteration(processHistory())) {
     auto it = pl.find(h.processName());
     if (it != pl.end()) {
       found += findGroupsForProcess(it->second, sel, res, wanted_wrapper);
     }
     if (stopIfProcessHasMatch && !res.empty())
       break;
   }
   return found;
 }

std::size_t Principal::findGroupsForProcess	(	std::vector< ProductID > const &	vpid,
		SelectorBase const &	selector,
		GroupQueryResultVec &	results,
		TypeID	wanted_wrapper
	)		const

private

Definition at line 377 of file Principal.cc.

References getGroup(), and art::SelectorBase::match().

Referenced by fillGroup(), and findGroups().

 {
   std::size_t found{}; // Horrible hack that should go away
   for (auto const pid : vpid) {
     auto group = getGroup(pid);
     if (!group) {
       continue;
     }
     if (!sel.match(group->productDescription())) {
       continue;
     }
     if (group->productUnavailable()) {
       continue;
     }
     if (wanted_wrapper) {
       group->resolveProduct(wanted_wrapper);
     } else {
       group->resolveProduct(group->producedWrapperType());
     }
     // If the product is a dummy filler, group will now be marked unavailable.
     // Unscheduled execution can fail to produce the EDProduct so check.
     if (group->productUnavailable()) {
       continue;
     }
     // Found a good match, save it.
     res.emplace_back(group);
     ++found;
   }
   return found;
 }

Principal::GroupQueryResultVec Principal::findGroupsForProduct	(	WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		bool	stopIfProcessHasMatch
	)		const

private

Definition at line 278 of file Principal.cc.

References findGroups(), findGroupsFromInputFile(), art::TypeID::friendlyClassName(), producedProducts_, art::WrappedTypeID::product_type, secondaryPrincipals_, tryNextSecondaryFile(), and art::WrappedTypeID::wrapped_product_type.

Referenced by fillGroup(), getByLabel(), getBySelector(), and getMany().

 {
   GroupQueryResultVec results;
 
   unsigned ret{};
   // Find groups from current process
   if (producedProducts_) {
     auto const& lookup = producedProducts_->productLookup;
     auto it = lookup.find(wrapped.product_type.friendlyClassName());
     if (it != lookup.end()) {
       ret += findGroups(it->second,
                         selector,
                         results,
                         stopIfProcessHasMatch,
                         wrapped.wrapped_product_type);
     }
   }
 
   // Look through currently opened input files
   ret +=
     findGroupsFromInputFile(wrapped, selector, results, stopIfProcessHasMatch);
   if (ret) {
     return results;
   }
 
   for (auto const& sp : secondaryPrincipals_) {
     if (sp->findGroupsFromInputFile(
           wrapped, selector, results, stopIfProcessHasMatch)) {
       return results;
     }
   }
 
   // Open more secondary files if necessary
   while (true) {
     int const err = tryNextSecondaryFile();
     if (err == -2) {
       // No more files.
       break;
     }
     if (err == -1) {
       // Run, SubRun, or Event not found.
       continue;
     }
     assert(!secondaryPrincipals_.empty());
     auto& new_sp = secondaryPrincipals_.back();
     if (new_sp->findGroupsFromInputFile(
           wrapped, selector, results, stopIfProcessHasMatch)) {
       return results;
     }
   }
   return results;
 }

std::size_t Principal::findGroupsFromInputFile	(	WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		GroupQueryResultVec &	results,
		bool	stopIfProcessHasMatch
	)		const

private

Definition at line 334 of file Principal.cc.

References findGroups(), art::TypeID::friendlyClassName(), presentProducts_, art::WrappedTypeID::product_type, and art::WrappedTypeID::wrapped_product_type.

Referenced by fillGroup(), and findGroupsForProduct().

 {
   if (!presentProducts_) {
     return 0;
   }
   auto const& lookup = presentProducts_->productLookup;
   auto it = lookup.find(wrapped.product_type.friendlyClassName());
   if (it == lookup.end()) {
     return 0;
   }
   return findGroups(it->second,
                     selector,
                     results,
                     stopIfProcessHasMatch,
                     wrapped.wrapped_product_type);
 }

GroupQueryResult Principal::getByLabel	(	WrappedTypeID const &	wrapped,
		std::string const &	label,
		std::string const &	productInstanceName,
		std::string const &	processName
	)		const

Definition at line 143 of file Principal.cc.

References findGroupsForProduct(), art::WrappedTypeID::product_type, and art::errors::ProductNotFound.

Referenced by art::DataViewImpl::getByLabel_().

 {
   Selector const sel{ModuleLabelSelector{label} &&
                      ProductInstanceNameSelector{productInstanceName} &&
                      ProcessNameSelector{processName}};
   auto const& results = findGroupsForProduct(wrapped, sel, true);
   if (results.empty()) {
     auto whyFailed =
       std::make_shared<art::Exception>(art::errors::ProductNotFound);
     *whyFailed << "getByLabel: Found zero products matching all criteria\n"
                << "Looking for type: " << wrapped.product_type << "\n"
                << "Looking for module label: " << label << "\n"
                << "Looking for productInstanceName: " << productInstanceName
                << "\n"
                << (processName.empty() ? "" : "Looking for process: ")
                << processName;
     return GroupQueryResult{whyFailed};
   }
   if (results.size() > 1) {
     throw art::Exception(art::errors::ProductNotFound)
       << "getByLabel: Found " << results.size()
       << " products rather than one which match all criteria\n"
       << "Looking for type: " << wrapped.product_type << "\n"
       << "Looking for module label: " << label << "\n"
       << "Looking for productInstanceName: " << productInstanceName << "\n"
       << (processName.empty() ? "" : "Looking for process: ") << processName
       << "\n";
   }
   return results[0];
 }

GroupQueryResult Principal::getByProductID ( ProductID const pid ) const

Definition at line 131 of file Principal.cc.

References getGroupForPtr(), and art::errors::ProductNotFound.

Referenced by art::DataViewImpl::getByProductID_(), getEDProductGetterImpl(), and productGetter().

 {
   if (auto const g = getGroupForPtr(pid)) {
     return GroupQueryResult{g};
   }
   auto whyFailed =
     std::make_shared<art::Exception>(art::errors::ProductNotFound, "InvalidID");
   *whyFailed << "getGroup: no product with given product id: " << pid << "\n";
   return GroupQueryResult{whyFailed};
 }

GroupQueryResult Principal::getBySelector	(	WrappedTypeID const &	wrapped,
		SelectorBase const &	sel
	)		const

Definition at line 110 of file Principal.cc.

References findGroupsForProduct(), art::WrappedTypeID::product_type, and art::errors::ProductNotFound.

Referenced by art::DataViewImpl::get_().

 {
   auto const& results = findGroupsForProduct(wrapped, sel, true);
   if (results.empty()) {
     auto whyFailed =
       std::make_shared<art::Exception>(art::errors::ProductNotFound);
     *whyFailed << "getBySelector: Found zero products matching all criteria\n"
                << "Looking for type: " << wrapped.product_type << "\n";
     return GroupQueryResult{whyFailed};
   }
   if (results.size() > 1) {
     throw art::Exception(art::errors::ProductNotFound)
       << "getBySelector: Found " << results.size()
       << " products rather than one which match all criteria\n"
       << "Looking for type: " << wrapped.product_type << "\n";
   }
   return results[0];
 }

EDProductGetter const* art::EDProductGetterFinder::getEDProductGetter ( ProductID const pid ) const

inlineinherited

Definition at line 25 of file EDProductGetterFinder.h.

References art::EDProductGetterFinder::getEDProductGetterImpl().

     {
       return getEDProductGetterImpl(pid);
     }

EDProductGetter const* art::Principal::getEDProductGetterImpl ( ProductID const pid ) const

inlinefinaloverrideprivatevirtual

Implements art::EDProductGetterFinder.

Definition at line 263 of file Principal.h.

References getByProductID(), and art::GroupQueryResult::result().

     {
       return getByProductID(pid).result().get();
     }

OutputHandle Principal::getForOutput	(	ProductID const	pid,
		bool	resolveProd
	)		const

Definition at line 424 of file Principal.cc.

References getResolvedGroup(), art::OutputHandle::invalid(), and art::OutputHandle::rangeOfValidity().

Referenced by art::RootOutputFile::fillBranches(), art::detail::KeptProvenance::insertAncestors(), and art::ProvenanceCheckerOutput::write().

 {
   auto const& g = getResolvedGroup(pid, resolveProd);
   if (g.get() == nullptr) {
     return OutputHandle::invalid();
   }
 
   if (resolveProd) {
     // If a request to resolve the product is made, then it should
     // exist and be marked as present.  Return invalid handles if this
     // is not the case.
     if (g->anyProduct() == nullptr) {
       return OutputHandle::invalid();
     }
     if (!g->anyProduct()->isPresent()) {
       return OutputHandle::invalid();
     }
   }
   if (!g->anyProduct() && !g->productProvenancePtr()) {
     return OutputHandle{g->rangeOfValidity()};
   }
   return OutputHandle{g->anyProduct(),
                       &g->productDescription(),
                       g->productProvenancePtr(),
                       g->rangeOfValidity()};
 }

cet::exempt_ptr< Group const > Principal::getGroup ( ProductID const pid ) const

protected

Definition at line 525 of file Principal.cc.

References groups_.

Referenced by fillGroup(), findGroupsForProcess(), getGroupForPtr(), art::EventPrincipal::history(), removeCachedProduct(), and art::EventPrincipal::throwIfExistingGroup().

 {
   auto it = groups_.find(pid);
   return it != groups_.cend() ? it->second.get() : nullptr;
 }

cet::exempt_ptr< Group const > Principal::getGroupForPtr ( ProductID const pid ) const

protected

Definition at line 481 of file Principal.cc.

References getGroup(), presentFromSource(), producedProducts_, secondaryPrincipals_, and tryNextSecondaryFile().

Referenced by fillGroup(), getByProductID(), and getResolvedGroup().

 {
   bool produced{false};
   if (producedProducts_) {
     auto const& availableProducts = producedProducts_->availableProducts;
     if (availableProducts.find(pid) != availableProducts.cend()) {
       produced = true;
     }
   }
 
   // Look through current process and currently opened primary input file.
   if (produced || presentFromSource(pid)) {
     return getGroup(pid);
   }
 
   // Look through secondary files
   for (auto const& sp : secondaryPrincipals_) {
     if (sp->presentFromSource(pid)) {
       return sp->getGroup(pid);
     }
   }
 
   // Try new secondary files
   while (true) {
     int const err = tryNextSecondaryFile();
     if (err == -2) {
       // No more files.
       return nullptr;
     }
     if (err == -1) {
       // Run, SubRun, or Event not found.
       continue;
     }
     assert(!secondaryPrincipals_.empty());
     auto& new_sp = secondaryPrincipals_.back();
     if (new_sp->presentFromSource(pid)) {
       return new_sp->getGroup(pid);
     }
   }
 
   return nullptr;
 }

Principal::GroupQueryResultVec Principal::getMany	(	WrappedTypeID const &	wrapped,
		SelectorBase const &	sel
	)		const

Definition at line 178 of file Principal.cc.

References findGroupsForProduct().

Referenced by art::DataViewImpl::getMany_().

 {
   return findGroupsForProduct(wrapped, sel, false);
 }

Principal::GroupQueryResultVec Principal::getMatchingSequence ( SelectorBase const & selector ) const

Definition at line 195 of file Principal.cc.

References findGroups(), matchingSequenceFromInputFile(), producedProducts_, secondaryPrincipals_, and tryNextSecondaryFile().

Referenced by art::DataViewImpl::getMatchingSequenceByLabel_().

 {
   GroupQueryResultVec results;
 
   // Find groups from current process
   if (producedProducts_) {
     if (findGroups(producedProducts_->viewLookup, selector, results, true) !=
         0) {
       return results;
     }
   }
 
   // Look through currently opened input files
   if (results.empty()) {
     results = matchingSequenceFromInputFile(selector);
     if (!results.empty()) {
       return results;
     }
 
     for (auto const& sp : secondaryPrincipals_) {
       results = sp->matchingSequenceFromInputFile(selector);
       if (!results.empty()) {
         return results;
       }
     }
   }
 
   // Open more secondary files if necessary
   if (results.empty()) {
     while (true) {
       int const err = tryNextSecondaryFile();
       if (err == -2) {
         // No more files.
         break;
       }
       if (err == -1) {
         // Run, SubRun, or Event not found.
         continue;
       }
       assert(!secondaryPrincipals_.empty());
       auto& new_sp = secondaryPrincipals_.back();
       results = new_sp->matchingSequenceFromInputFile(selector);
       if (!results.empty()) {
         return results;
       }
     }
   }
 
   return results;
 }

cet::exempt_ptr< Group const > Principal::getResolvedGroup	(	ProductID const	pid,
		bool	resolveProd
	)		const

protected

Definition at line 452 of file Principal.cc.

References getGroupForPtr().

Referenced by fillGroup(), and getForOutput().

 {
   // FIXME: This reproduces the behavior of the original getGroup with
   // resolveProv == false but I am not sure this is correct in the
   // case of an unavailable product.
   auto const g = getGroupForPtr(pid);
   if (!g.get() || !resolveProd) {
     return g;
   }
   bool const gotIt = g->resolveProductIfAvailable(g->producedWrapperType());
   if (!gotIt) {
     // Behavior is the same as if the group wasn't there.
     return nullptr;
   }
   return g;
 }

Principal::GroupQueryResultVec Principal::matchingSequenceFromInputFile ( SelectorBase const & selector ) const

private

Definition at line 247 of file Principal.cc.

References findGroups(), and presentProducts_.

Referenced by fillGroup(), and getMatchingSequence().

 {
   GroupQueryResultVec results;
   if (!presentProducts_) {
     return results;
   }
 
   findGroups(presentProducts_->viewLookup, selector, results, true);
   return results;
 }

Principal& art::Principal::operator= ( Principal const & )

delete

bool Principal::presentFromSource ( ProductID pid ) const

private

Definition at line 470 of file Principal.cc.

References art::productstatus::present(), and presentProducts_.

Referenced by fillGroup(), and getGroupForPtr().

 {
   bool present{false};
   if (presentProducts_) {
     auto const& lookup = presentProducts_->availableProducts;
     present = (lookup.find(pid) != lookup.cend());
   }
   return present;
 }

ProcessConfiguration const& art::Principal::processConfiguration ( ) const

inline

Definition at line 138 of file Principal.h.

References processConfiguration_.

Referenced by art::get_ProductDescription().

     {
       return processConfiguration_;
     }

ProcessHistory const& art::Principal::processHistory ( ) const

inline

Definition at line 132 of file Principal.h.

References processHistory_.

Referenced by findGroups(), and art::DataViewImpl::processHistory().

     {
       return processHistory_;
     }

virtual ProcessHistoryID const& art::Principal::processHistoryID ( ) const

privatepure virtual

Implemented in art::EventPrincipal, art::SubRunPrincipal, art::RunPrincipal, and art::ResultsPrincipal.

Referenced by fillGroup().

EDProductGetter const * Principal::productGetter ( ProductID const pid ) const

Definition at line 532 of file Principal.cc.

References deferredGetter_(), getByProductID(), and art::GroupQueryResult::result().

Referenced by art::SourceHelper::makePtr(), art::Results::productGetter(), art::Run::productGetter(), art::SubRun::productGetter(), and art::Event::productGetter().

 {
   EDProductGetter const* result{getByProductID(pid).result().get()};
   return result ? result : deferredGetter_(pid);
 }

DelayedReader& art::Principal::productReader ( )

inlineprotected

Definition at line 198 of file Principal.h.

References store_.

Referenced by art::EventPrincipal::EventPrincipal(), art::ResultsPrincipal::ResultsPrincipal(), art::RunPrincipal::RunPrincipal(), and art::SubRunPrincipal::SubRunPrincipal().

     {
       return *store_;
     }

void art::Principal::readImmediate ( ) const

inline

Definition at line 112 of file Principal.h.

References groups_, and readProvenanceImmediate().

     {
       readProvenanceImmediate();
       for (auto const& val : groups_) {
         if (!val.second->productUnavailable()) {
           val.second->resolveProduct(val.second->producedWrapperType());
         }
       }
     }

void art::Principal::readProvenanceImmediate ( ) const

inline

Definition at line 123 of file Principal.h.

References branchMapperPtr_, and groups_.

Referenced by readImmediate().

     {
       for (auto const& val : groups_) {
         (void)val.second->productProvenancePtr();
       }
       branchMapperPtr_->setDelayedRead(false);
     }

void Principal::removeCachedProduct ( ProductID const pid ) const

Definition at line 259 of file Principal.cc.

References getGroup(), art::errors::ProductNotFound, and secondaryPrincipals_.

Referenced by art::DataViewImpl::removeCachedProduct_().

 {
   if (auto g = getGroup(pid)) {
     g->removeCachedProduct();
     return;
   }
   for (auto const& sp : secondaryPrincipals_) {
     if (auto g = sp->getGroup(pid)) {
       g->removeCachedProduct();
       return;
     }
   }
   throw Exception(errors::ProductNotFound, "removeCachedProduct")
     << "Attempt to remove unknown product corresponding to ProductID: " << pid
     << '\n'
     << "Please contact artists@fnal.gov\n";
 }

virtual RangeSet art::Principal::seenRanges ( ) const

pure virtual

Implemented in art::EventPrincipal, art::SubRunPrincipal, art::RunPrincipal, and art::ResultsPrincipal.

Referenced by cend(), and art::RootOutputFile::fillBranches().

virtual void art::Principal::setProcessHistoryID ( ProcessHistoryID const & )

privatepure virtual

Implemented in art::EventPrincipal, art::SubRunPrincipal, art::RunPrincipal, and art::ResultsPrincipal.

Referenced by addToProcessHistory(), and fillGroup().

void art::Principal::setProducedProducts ( ProductTable const & producedProducts )

inline

Definition at line 106 of file Principal.h.

References producedProducts_.

     {
       producedProducts_ = cet::make_exempt_ptr(&producedProducts);
     }

size_t art::Principal::size ( void ) const

inline

Definition at line 150 of file Principal.h.

References groups_.

Referenced by art::DataViewImpl::size().

     {
       return groups_.size();
     }

int Principal::tryNextSecondaryFile ( ) const

protected

Definition at line 184 of file Principal.cc.

References nextSecondaryFileIdx_, and store_.

Referenced by fillGroup(), findGroupsForProduct(), getGroupForPtr(), and getMatchingSequence().

 {
   int const err = store_->openNextSecondaryFile(nextSecondaryFileIdx_);
   if (err != -2) {
     // there are more files to try
     ++nextSecondaryFileIdx_;
   }
   return err;
 }