#include "Principal.h"

Inheritance diagram for art::Principal:

Public Types
enum	allowed_processes { allowed_processes::current_process, allowed_processes::input_source, allowed_processes::all }

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

using	const_iterator = GroupCollection::const_iterator

Public Member Functions
virtual	~Principal () noexcept=default

	Principal (BranchType, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, ProcessHistoryID const &id, std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >())

	Principal (Principal const &)=delete

Principal &	operator= (Principal const &)=delete

GroupQueryResult	getByProductID (ProductID const pid) const

GroupQueryResult	getBySelector (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

GroupQueryResult	getByLabel (ModuleContext const &mc, WrappedTypeID const &wrapped, std::string const &label, std::string const &productInstanceName, ProcessTag const &processTag) const

std::vector< GroupQueryResult >	getMany (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

std::vector< InputTag >	getInputTags (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

std::vector< cet::exempt_ptr< Group > >	getMatchingSequence (ModuleContext const &, SelectorBase const &, ProcessTag const &) const

EDProductGetter const *	productGetter (ProductID id) const

Provenance	provenance (ProductID id) const

ProcessHistory const &	processHistory () const

OutputHandle	getForOutput (ProductID const &, bool resolveProd) const

cet::exempt_ptr< BranchDescription const >	getProductDescription (ProductID const pid, bool const alwaysEnableLookupOfProducedProducts=false) const

void	createGroupsForProducedProducts (ProductTables const &producedProducts)

void	enableLookupOfProducedProducts ()

void	markProcessHistoryAsModified ()

void	readImmediate () const

ProcessConfiguration const &	processConfiguration () const

ProcessHistoryID const &	processHistoryID () const

cet::exempt_ptr< ProductProvenance const >	branchToProductProvenance (ProductID const &) const

size_t	size () const

const_iterator	begin () const

const_iterator	cbegin () const

const_iterator	end () const

const_iterator	cend () const

void	addToProcessHistory ()

BranchType	branchType () const

RangeSet	seenRanges () const

void	put (BranchDescription const &, std::unique_ptr< ProductProvenance const > &&, std::unique_ptr< EDProduct > &&, std::unique_ptr< RangeSet > &&)

EDProductGetter const *	getEDProductGetter (ProductID const &pid) const

Protected Member Functions
std::optional< ProductInserter >	makeInserter (ModuleContext const &mc)

void	fillGroup (BranchDescription const &)

void	setProcessHistoryIDcombined (ProcessHistoryID const &)

void	updateSeenRanges (RangeSet const &rs)

Private Member Functions
void	ctor_create_groups (cet::exempt_ptr< ProductTable const >)

void	ctor_read_provenance ()

void	ctor_fetch_process_history (ProcessHistoryID const &)

cet::exempt_ptr< Group >	getGroupLocal (ProductID const) const

std::vector< cet::exempt_ptr< Group > >	matchingSequenceFromInputFile (ModuleContext const &, SelectorBase const &) const

size_t	findGroupsFromInputFile (ModuleContext const &, WrappedTypeID const &wrapped, SelectorBase const &, std::vector< cet::exempt_ptr< Group >> &results) const

size_t	findGroups (ProcessLookup const &, ModuleContext const &, SelectorBase const &, std::vector< cet::exempt_ptr< Group >> &groups) const

size_t	findGroupsForProcess (std::vector< ProductID > const &vpid, ModuleContext const &mc, SelectorBase const &selector, std::vector< cet::exempt_ptr< Group >> &groups) const

bool	producedInProcess (ProductID) const

bool	presentFromSource (ProductID) const

auto	tryNextSecondaryFile () const

std::vector< cet::exempt_ptr< Group > >	findGroupsForProduct (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

EDProductGetter const *	getEDProductGetter_ (ProductID const &) const override

cet::exempt_ptr< Group >	getGroupTryAllFiles (ProductID const) const

Private Attributes
BranchType	branchType_ {}

ProcessHistory	processHistory_ {}

std::atomic< bool >	processHistoryModified_ {false}

ProcessConfiguration const &	processConfiguration_

std::atomic< ProductTable const * >	presentProducts_

std::atomic< ProductTable const * >	producedProducts_ {nullptr}

std::atomic< bool >	enableLookupOfProducedProducts_ {false}

std::recursive_mutex	groupMutex_ {}

GroupCollection	groups_ {}

std::unique_ptr< DelayedReader >	delayedReader_ {nullptr}

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

int	nextSecondaryFileIdx_ {}

RangeSet	rangeSet_ {RangeSet::invalid()}

Detailed Description

Definition at line 49 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.

Member Enumeration Documentation

enum art::Principal::allowed_processes

strong

Enumerator
current_process
input_source
all

Definition at line 53 of file Principal.h.

53 { current_process, input_source, all };

Constructor & Destructor Documentation

virtual art::Principal::~Principal ( )

virtualdefaultnoexcept

art::Principal::Principal	(	BranchType	branchType,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		ProcessHistoryID const &	id,
		std::unique_ptr< DelayedReader > &&	reader = `std::make_unique<NoDelayedReader>()`
	)

Definition at line 119 of file Principal.cc.

References ctor_create_groups(), ctor_fetch_process_history(), ctor_read_provenance(), delayedReader_, hist, presentProducts_, and processConfiguration_.

     : branchType_{branchType}
     , processConfiguration_{pc}
     , presentProducts_{presentProducts.get()}
     , delayedReader_{std::move(reader)}
   {
     delayedReader_->setPrincipal(this);
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(hist);
   }

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

delete

Member Function Documentation

void art::Principal::addToProcessHistory ( )

Definition at line 423 of file Principal.cc.

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

Referenced by createGroupsForProducedProducts(), and processHistoryID().

   {
     bool expected = false;
     if (processHistoryModified_.compare_exchange_strong(expected, true)) {
       // MT note: We have now locked out any other task trying to
       //          modify the process history. Now we have to block
       //          tasks that already have a pointer to the process
       //          history from accessing its internals while we update
       //          it. We do not protect the iteration interface, the
       //          begin(), end(), and size() are all separate calls
       //          and we cannot lock in each one because there is no
       //          way to automatically unlock.
       std::lock_guard sentry{processHistory_.get_mutex()};
       string const& processName = processConfiguration_.processName();
       for (auto const& val : processHistory_) {
         if (processName == val.processName()) {
           throw 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_);
     }
   }

Principal::const_iterator art::Principal::begin ( ) const

Definition at line 270 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.begin();
   }

cet::exempt_ptr< ProductProvenance const > art::Principal::branchToProductProvenance ( ProductID const & pid ) const

Definition at line 298 of file Principal.cc.

References getGroupLocal().

Referenced by art::markAncestors(), and processHistoryID().

   {
     // Note: The input source lock will be held when this routine is called.
     //
     // MT-TODO: For right now ignore the delay reading option for
     //          product provenance. If we do the delay reading then we
     //          must use a lock to interlock all fetches of provenance
     //          because the delay read fills the pp_by_pid_ one entry
     //          at a time, and we do not want other threads to find
     //          the info only partly there.
     cet::exempt_ptr<ProductProvenance const> ret;
     auto g = getGroupLocal(pid);
     if (g.get() != nullptr) {
       ret = g->productProvenance();
     }
     return ret;
   }

BranchType art::Principal::branchType ( ) const

Definition at line 807 of file Principal.cc.

References branchType_.

Referenced by art::SourceHelper::makePtr(), and processHistoryID().

   {
     return branchType_;
   }

Principal::const_iterator art::Principal::cbegin ( ) const

Definition at line 277 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.cbegin();
   }

Principal::const_iterator art::Principal::cend ( ) const

Definition at line 291 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.cend();
   }

void art::Principal::createGroupsForProducedProducts ( ProductTables const & producedProducts )

Definition at line 201 of file Principal.cc.

References addToProcessHistory(), branchType_, fillGroup(), art::ProductTables::get(), producedProducts_, and util::values().

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

   {
     auto const& produced = producedProducts.get(branchType_);
     producedProducts_ = &produced;
     if (produced.descriptions.empty()) {
       return;
     }
     // The process history is expanded if there is a product that is
     // produced in this process.
     addToProcessHistory();
     for (auto const& pd : produced.descriptions | ::ranges::views::values) {
       assert(pd.branchType() == branchType_);
       // Create a group for the produced product.
       fillGroup(pd);
     }
   }

void art::Principal::ctor_create_groups ( cet::exempt_ptr< ProductTable const > presentProducts )

private

Definition at line 68 of file Principal.cc.

References util::values().

Referenced by Principal(), and processHistoryID().

   {
     if (!presentProducts) {
       return;
     }
     // Note: Dropped products are a problem. We should not create
     //       groups for them now because later we may open a secondary
     //       file which actually contains them and we want the
     //       secondary principal to have those groups. However some
     //       code expects to be able to find a group for dropped
     //       products, so getGroupTryAllFiles ignores groups for
     //       dropped products instead.
     for (auto const& pd :
          presentProducts->descriptions | ::ranges::views::values) {
       assert(pd.branchType() == branchType_);
       fillGroup(pd);
     }
   }

void art::Principal::ctor_fetch_process_history ( ProcessHistoryID const & phid )

private

Definition at line 109 of file Principal.cc.

References util::get(), art::Hash< I >::isValid(), and std::swap().

Referenced by Principal(), and processHistoryID().

   {
     if (!phid.isValid()) {
       return;
     }
     ProcessHistory processHistory;
     ProcessHistoryRegistry::get(phid, processHistory);
     std::swap(processHistory_, processHistory);
   }

void art::Principal::ctor_read_provenance ( )

private

Definition at line 89 of file Principal.cc.

References art::productstatus::dummyToPreventDoubleCount(), and art::productstatus::unknown().

Referenced by Principal(), and processHistoryID().

   {
     for (auto&& provenance : delayedReader_->readProvenance()) {
       auto g = getGroupLocal(provenance.productID());
       if (g.get() == nullptr) {
         continue;
       }
       if (provenance.productStatus() != productstatus::unknown()) {
         g->setProductProvenance(make_unique<ProductProvenance>(provenance));
       } else {
         // We have an old format file, convert.
         g->setProductProvenance(make_unique<ProductProvenance>(
           provenance.productID(),
           productstatus::dummyToPreventDoubleCount(),
           provenance.parentage().parents()));
       }
     }
   }

void art::Principal::enableLookupOfProducedProducts ( )

Definition at line 220 of file Principal.cc.

References enableLookupOfProducedProducts_.

   {
     enableLookupOfProducedProducts_ = true;
   }

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

Definition at line 284 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.end();
   }

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

protected

Definition at line 137 of file Principal.cc.

References util::cend(), art::combinable(), art::errors::Configuration, delayedReader_, groupMutex_, groups_, art::BranchDescription::processName(), art::BranchDescription::productID(), and art::errors::ProductRegistrationFailure.

Referenced by createGroupsForProducedProducts(), and processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     auto it = groups_.find(pd.productID());
     if (it != std::cend(groups_)) {
       // The 'combinable' call does not require that the processing
       // history be the same, which is not what we are checking for here.
       auto const& found_pd = it->second->productDescription();
       if (combinable(found_pd, pd)) {
         throw Exception(errors::Configuration)
           << "The process name " << pd.processName()
           << " was previously used on these products.\n"
           << "Please modify the configuration file to use a "
           << "distinct process name.\n";
       }
       throw Exception(errors::ProductRegistrationFailure)
         << "The product ID " << pd.productID() << " of the new product:\n"
         << pd
         << " collides with the product ID of the already-existing product:\n"
         << found_pd
         << "Please modify the instance name of the new product so as to avoid "
            "the product ID collision.\n"
         << "In addition, please notify artists@fnal.gov of this error.\n";
     }
 
     groups_[pd.productID()] = create_group(delayedReader_.get(), pd);
   }

std::size_t art::Principal::findGroups	(	ProcessLookup const &	pl,
		ModuleContext const &	mc,
		SelectorBase const &	sel,
		std::vector< cet::exempt_ptr< Group >> &	groups
	)		const

private

Definition at line 461 of file Principal.cc.

References findGroupsForProcess(), art::ProcessHistory::get_mutex(), and processHistory_.

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

   {
     // 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{};
     // MT note: We must protect the process history iterators here
     //          against possible invalidation by output modules
     //          inserting a process history entry while we are
     //          iterating.
     std::lock_guard sentry{processHistory_.get_mutex()};
     // We must skip over duplicate entries of the same process
     // configuration in the process history.  This unfortunately
     // happened with the SamplingInput source.
     for (auto const& h :
          ::ranges::views::reverse(processHistory_) | ::ranges::views::unique) {
       if (auto it = pl.find(h.processName()); it != pl.end()) {
         found += findGroupsForProcess(it->second, mc, sel, groups);
       }
     }
     return found;
   }

std::size_t art::Principal::findGroupsForProcess	(	std::vector< ProductID > const &	vpid,
		ModuleContext const &	mc,
		SelectorBase const &	selector,
		std::vector< cet::exempt_ptr< Group >> &	groups
	)		const

private

Definition at line 667 of file Principal.cc.

References getGroupLocal(), art::SelectorBase::match(), art::ModuleContext::onSamePathAs(), and art::ModuleContext::onTriggerPath().

Referenced by findGroups(), and processHistoryID().

   {
     std::size_t found{}; // Horrible hack that should go away
     for (auto const pid : vpid) {
       auto group = getGroupLocal(pid);
       if (!group) {
         continue;
       }
       auto const& pd = group->productDescription();
       if (pd.dropped()) {
         continue;
       }
       // If we are processing a trigger path, the only visible
       // produced products are those that originate from modules on
       // the same path we're currently processing.
       if (mc.onTriggerPath() && pd.produced() &&
           !mc.onSamePathAs(pd.moduleLabel())) {
         continue;
       }
       if (!sel.match(pd)) {
         continue;
       }
       // Found a good match, save it.
       res.emplace_back(group);
       ++found;
     }
     return found;
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::findGroupsForProduct	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		ProcessTag const &	processTag
	)		const

private

Definition at line 625 of file Principal.cc.

References art::ProcessTag::current_process_search_allowed(), enableLookupOfProducedProducts_, findGroups(), findGroupsFromInputFile(), art::TypeID::friendlyClassName(), art::ProcessTag::input_source_search_allowed(), producedProducts_, art::WrappedTypeID::product_type, secondaryPrincipals_, and tryNextSecondaryFile().

Referenced by getBySelector(), getInputTags(), getMany(), and processHistoryID().

   {
     std::vector<cet::exempt_ptr<Group>> results;
     unsigned ret{};
     // Find groups from current process
     if (processTag.current_process_search_allowed() &&
         enableLookupOfProducedProducts_.load()) {
       auto const& lookup = producedProducts_.load()->productLookup;
       auto it = lookup.find(wrapped.product_type.friendlyClassName());
       if (it != lookup.end()) {
         ret += findGroups(it->second, mc, selector, results);
       }
     }
 
     if (!processTag.input_source_search_allowed()) {
       return results;
     }
 
     // Look through currently opened input files
     ret += findGroupsFromInputFile(mc, wrapped, selector, results);
     if (ret) {
       return results;
     }
     for (auto const& sp : secondaryPrincipals_) {
       if (sp->findGroupsFromInputFile(mc, wrapped, selector, results)) {
         return results;
       }
     }
     // Open more secondary files if necessary
     while (auto sp = tryNextSecondaryFile()) {
       auto& new_sp = secondaryPrincipals_.emplace_back(std::move(sp));
       if (new_sp->findGroupsFromInputFile(mc, wrapped, selector, results)) {
         return results;
       }
     }
     return results;
   }

std::size_t art::Principal::findGroupsFromInputFile	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		std::vector< cet::exempt_ptr< Group >> &	results
	)		const

private

Definition at line 607 of file Principal.cc.

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

Referenced by findGroupsForProduct(), and processHistoryID().

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

GroupQueryResult art::Principal::getByLabel	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		std::string const &	label,
		std::string const &	productInstanceName,
		ProcessTag const &	processTag
	)		const

Definition at line 506 of file Principal.cc.

References getBySelector(), and art::ProcessTag::name().

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

   {
     auto const& processName = processTag.name();
     Selector const sel{ModuleLabelSelector{label} &&
                        ProductInstanceNameSelector{productInstanceName} &&
                        ProcessNameSelector{processName}};
     return getBySelector(mc, wrapped, sel, processTag);
   }

GroupQueryResult art::Principal::getByProductID ( ProductID const pid ) const

Definition at line 839 of file Principal.cc.

References branchType_, getGroupTryAllFiles(), and art::errors::ProductNotFound.

Referenced by art::ProductRetriever::getByProductID_(), and art::ProductRetriever::getProductProvenance().

   {
     if (auto g = getGroupTryAllFiles(pid)) {
       return GroupQueryResult{g};
     }
     auto whyFailed =
       make_shared<Exception>(errors::ProductNotFound, "InvalidID");
     *whyFailed << "Principal::getByProductID: no product with branch type: "
                << branchType_ << " product id: " << pid << '\n';
     return GroupQueryResult{whyFailed};
   }

GroupQueryResult art::Principal::getBySelector	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 488 of file Principal.cc.

References findGroupsForProduct(), art::detail::indent(), art::SelectorBase::print(), art::WrappedTypeID::product_type, art::errors::ProductNotFound, and art::resolve_unique_product().

Referenced by getByLabel(), and art::ProductRetriever::getBySelector_().

   {
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     auto const result = resolve_unique_product(groups, wrapped);
     if (!result.has_value()) {
       auto whyFailed = std::make_shared<Exception>(errors::ProductNotFound);
       *whyFailed << "Found zero products matching all selection criteria\n"
                  << indent << "C++ type: " << wrapped.product_type << '\n'
                  << sel.print(indent) << '\n';
       return GroupQueryResult{whyFailed};
     }
     return *result;
   }

EDProductGetter const * art::PrincipalBase::getEDProductGetter ( ProductID const & pid ) const

inherited

Definition at line 12 of file PrincipalBase.cc.

References art::PrincipalBase::getEDProductGetter_().

   {
     return getEDProductGetter_(pid);
   }

EDProductGetter const * art::Principal::getEDProductGetter_ ( ProductID const & pid ) const

overrideprivatevirtual

Implements art::PrincipalBase.

Definition at line 195 of file Principal.cc.

References productGetter().

Referenced by processHistoryID().

   {
     return productGetter(pid);
   }

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

Definition at line 750 of file Principal.cc.

References getGroupTryAllFiles(), art::OutputHandle::invalid(), art::OutputHandle::productProvenance(), and art::OutputHandle::rangeOfValidity().

   {
     // MT-FIXME: Uses of group!
     auto g = getGroupTryAllFiles(pid);
     if (g.get() == nullptr) {
       return OutputHandle::invalid();
     }
     if (resolveProd) {
       if (!g->resolveProductIfAvailable()) {
         // Behavior is the same as if the group wasn't there.
         return OutputHandle::invalid();
       }
       if (g->anyProduct() == nullptr) {
         return OutputHandle::invalid();
       }
       if (!g->anyProduct()->isPresent()) {
         return OutputHandle::invalid();
       }
     }
     if (!g->anyProduct() && !g->productProvenance()) {
       return OutputHandle{g->rangeOfValidity()};
     }
     return OutputHandle{g->anyProduct(),
                         &g->productDescription(),
                         g->productProvenance(),
                         g->rangeOfValidity()};
   }

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

private

Definition at line 852 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by branchToProductProvenance(), findGroupsForProcess(), getGroupTryAllFiles(), processHistoryID(), provenance(), and put().

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

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

private

Definition at line 860 of file Principal.cc.

References getGroupLocal(), presentFromSource(), producedInProcess(), secondaryPrincipals_, and tryNextSecondaryFile().

Referenced by getByProductID(), getForOutput(), processHistoryID(), and productGetter().

   {
     // Look through current process and currently opened primary input file.
     if (producedInProcess(pid) || presentFromSource(pid)) {
       return getGroupLocal(pid);
     }
     // Look through secondary files
     for (auto const& sp : secondaryPrincipals_) {
       if (sp->presentFromSource(pid)) {
         return sp->getGroupLocal(pid);
       }
     }
     // Try new secondary files
     while (auto sp = tryNextSecondaryFile()) {
       auto& new_sp = secondaryPrincipals_.emplace_back(std::move(sp));
       if (new_sp->presentFromSource(pid)) {
         return new_sp->getGroupLocal(pid);
       }
     }
     return nullptr;
   }

std::vector< InputTag > art::Principal::getInputTags	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 520 of file Principal.cc.

References findGroupsForProduct().

Referenced by art::ProductRetriever::getInputTags_().

   {
     std::vector<InputTag> tags;
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     cet::transform_all(groups, back_inserter(tags), [](auto const g) {
       return g->productDescription().inputTag();
     });
     return tags;
   }

std::vector< GroupQueryResult > art::Principal::getMany	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 534 of file Principal.cc.

References findGroupsForProduct(), art::resolve_products(), and art::WrappedTypeID::wrapped_product_type.

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

   {
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     return resolve_products(groups, wrapped.wrapped_product_type);
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::getMatchingSequence	(	ModuleContext const &	mc,
		SelectorBase const &	selector,
		ProcessTag const &	processTag
	)		const

Definition at line 550 of file Principal.cc.

References art::ProcessTag::current_process_search_allowed(), enableLookupOfProducedProducts_, findGroups(), art::ProcessTag::input_source_search_allowed(), matchingSequenceFromInputFile(), producedProducts_, secondaryPrincipals_, and tryNextSecondaryFile().

Referenced by art::ProductRetriever::getContainerForView_().

   {
     std::vector<cet::exempt_ptr<Group>> groups;
     // Find groups from current process
     if (processTag.current_process_search_allowed() &&
         enableLookupOfProducedProducts_.load()) {
       if (findGroups(
             producedProducts_.load()->viewLookup, mc, selector, groups) != 0) {
         return groups;
       }
     }
 
     if (!processTag.input_source_search_allowed()) {
       return groups;
     }
 
     // Look through currently opened input files
     if (groups.empty()) {
       groups = matchingSequenceFromInputFile(mc, selector);
       if (!groups.empty()) {
         return groups;
       }
       for (auto const& sp : secondaryPrincipals_) {
         groups = sp->matchingSequenceFromInputFile(mc, selector);
         if (!groups.empty()) {
           return groups;
         }
       }
     }
     // Open more secondary files if necessary
     if (groups.empty()) {
       while (auto sp = tryNextSecondaryFile()) {
         auto& new_sp = secondaryPrincipals_.emplace_back(std::move(sp));
         groups = new_sp->matchingSequenceFromInputFile(mc, selector);
         if (!groups.empty()) {
           return groups;
         }
       }
     }
     return groups;
   }

cet::exempt_ptr< BranchDescription const > art::Principal::getProductDescription	(	ProductID const	pid,
		bool const	alwaysEnableLookupOfProducedProducts = `false`
	)		const

Definition at line 779 of file Principal.cc.

References enableLookupOfProducedProducts_, presentProducts_, producedProducts_, and secondaryPrincipals_.

Referenced by art::ProductRetriever::getProductDescription(), art::ProductInserter::getProductDescription_(), and art::ProductRetriever::getProductID_().

   {
     // Find groups from current process
     if (alwaysEnableLookupOfProducedProducts ||
         enableLookupOfProducedProducts_.load()) {
       if (producedProducts_.load() != nullptr) {
         if (auto result = producedProducts_.load()->description(pid)) {
           return result;
         }
       }
     }
     if (presentProducts_.load()) {
       // Look through currently opened input files
       if (auto result = presentProducts_.load()->description(pid)) {
         return result;
       }
     }
     for (auto const& sp : secondaryPrincipals_) {
       if (auto result = sp->getProductDescription(pid)) {
         return result;
       }
     }
     return nullptr;
   }

std::optional< ProductInserter > art::Principal::makeInserter ( ModuleContext const & mc )

protected

Definition at line 813 of file Principal.cc.

References branchType_.

Referenced by art::EventPrincipal::makeEvent(), art::ResultsPrincipal::makeResults(), art::RunPrincipal::makeRun(), art::SubRunPrincipal::makeSubRun(), and processHistoryID().

   {
     return std::make_optional<ProductInserter>(branchType_, *this, mc);
   }

void art::Principal::markProcessHistoryAsModified ( )

Definition at line 170 of file Principal.cc.

References processHistoryModified_.

   {
     processHistoryModified_ = true;
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::matchingSequenceFromInputFile	(	ModuleContext const &	mc,
		SelectorBase const &	selector
	)		const

private

Definition at line 595 of file Principal.cc.

References findGroups(), and presentProducts_.

Referenced by getMatchingSequence(), and processHistoryID().

   {
     std::vector<cet::exempt_ptr<Group>> groups;
     if (!presentProducts_.load()) {
       return groups;
     }
     findGroups(presentProducts_.load()->viewLookup, mc, selector, groups);
     return groups;
   }

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

delete

bool art::Principal::presentFromSource ( ProductID pid ) const

private

Definition at line 829 of file Principal.cc.

References presentProducts_.

Referenced by getGroupTryAllFiles(), and processHistoryID().

   {
     if (!presentProducts_.load()) {
       return false;
     }
     auto pd = presentProducts_.load()->description(pid);
     return pd == nullptr ? false : pd->present();
   }

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

Definition at line 257 of file Principal.cc.

References processConfiguration_.

   {
     return processConfiguration_;
   }

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

Definition at line 247 of file Principal.cc.

References processHistory_.

Referenced by art::ProductRetriever::getProcessParameterSet(), art::Event::processHistory(), art::Run::processHistory(), and art::SubRun::processHistory().

   {
     // MT note: We make no attempt to protect callers who use this
     //          call to get access to the iteration interface of the
     //          process history.  See the threading notes there and
     //          here for the reasons why.
     return processHistory_;
   }

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

inline

Definition at line 148 of file Principal.h.

References addToProcessHistory(), begin(), branchToProductProvenance(), branchType(), cbegin(), cend(), ctor_create_groups(), ctor_fetch_process_history(), ctor_read_provenance(), end(), fillGroup(), findGroups(), findGroupsForProcess(), findGroupsForProduct(), findGroupsFromInputFile(), getEDProductGetter_(), getGroupLocal(), getGroupTryAllFiles(), art::ProcessHistory::id(), makeInserter(), matchingSequenceFromInputFile(), presentFromSource(), processHistory_, producedInProcess(), put(), seenRanges(), setProcessHistoryIDcombined(), size(), tryNextSecondaryFile(), updateSeenRanges(), and lar::dump::vector().

Referenced by art::RunPrincipal::createGroupsForProducedProducts(), art::ResultsPrincipal::createGroupsForProducedProducts(), art::SubRunPrincipal::createGroupsForProducedProducts(), art::Event::processHistoryID(), and art::EventPrincipal::refreshProcessHistoryID().

     {
       return processHistory_.id();
     }

bool art::Principal::producedInProcess ( ProductID pid ) const

private

Definition at line 819 of file Principal.cc.

References enableLookupOfProducedProducts_, and producedProducts_.

Referenced by getGroupTryAllFiles(), and processHistoryID().

   {
     if (!enableLookupOfProducedProducts_.load()) {
       return false;
     }
     auto pd = producedProducts_.load()->description(pid);
     return pd == nullptr ? false : pd->produced();
   }

EDProductGetter const * art::Principal::productGetter ( ProductID id ) const

Definition at line 177 of file Principal.cc.

References getGroupTryAllFiles().

Referenced by getEDProductGetter_(), art::SourceHelper::makePtr(), art::ProductRetriever::productGetter(), and art::ProductInserter::productGetter_().

   {
     auto g = getGroupTryAllFiles(pid);
     if (g.get() != nullptr) {
       // Note: All produced products should be found.
       return g.get();
     }
     return nullptr;
   }

Provenance art::Principal::provenance ( ProductID id ) const

Definition at line 189 of file Principal.cc.

References getGroupLocal().

Referenced by art::ProductInserter::provenance_().

   {
     return Provenance{getGroupLocal(pid)};
   }

void art::Principal::put	(	BranchDescription const &	bd,
		std::unique_ptr< ProductProvenance const > &&	pp,
		std::unique_ptr< EDProduct > &&	edp,
		std::unique_ptr< RangeSet > &&	rs
	)

Definition at line 713 of file Principal.cc.

References art::BranchDescription::branchName(), branchType_, getGroupLocal(), art::RangeSet::invalid(), art::BranchDescription::productID(), art::errors::ProductRegistrationFailure, and art::detail::range_sets_supported().

Referenced by art::ProductInserter::commitProducts(), and processHistoryID().

   {
     assert(edp);
     if (detail::range_sets_supported(branchType_)) {
       // Note: We intentionally allow group and provenance replacement
       //       for run and subrun products.
       auto group = getGroupLocal(bd.productID());
       assert(group);
       group->setProductAndProvenance(
         std::move(pp), std::move(edp), std::move(rs));
     } else {
       auto group = getGroupLocal(bd.productID());
       assert(group);
       if (group->anyProduct() != nullptr) {
         throw Exception(errors::ProductRegistrationFailure, "Principal::put:")
           << "Problem found during put of " << branchType_
           << " product: product already put for " << bd.branchName() << '\n';
       }
       group->setProductAndProvenance(
         std::move(pp),
         std::move(edp),
         make_unique<RangeSet>(RangeSet::invalid()));
     }
   }

void art::Principal::readImmediate ( ) const

Definition at line 226 of file Principal.cc.

References groupMutex_, groups_, and util::values().

   {
     // Read all data products and provenance immediately, if
     // available.  Used only by RootInputFile to implement the
     // delayedRead*Products config options.
     //
     // Note: The input source lock will be held when this routine is called.
     //
     // MT-TODO: For right now ignore the delay reading option for
     //          product provenance. If we do the delay reading then we
     //          must use a lock to interlock all fetches of provenance
     //          because the delay read fills the pp_by_pid_ one entry
     //          at a time, and we do not want other threads to find
     //          the info only partly there.
     std::lock_guard sentry{groupMutex_};
     for (auto const& group : groups_ | ::ranges::views::values) {
       group->resolveProductIfAvailable();
     }
   }

RangeSet art::Principal::seenRanges ( ) const

Definition at line 701 of file Principal.cc.

References rangeSet_.

Referenced by art::detail::Producer::doEndRun(), art::detail::Filter::doEndRun(), art::detail::Producer::doEndSubRun(), art::detail::Filter::doEndSubRun(), and processHistoryID().

   {
     return rangeSet_;
   }

void art::Principal::setProcessHistoryIDcombined ( ProcessHistoryID const & )

protected

Referenced by processHistoryID().

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

Definition at line 263 of file Principal.cc.

References groupMutex_, and groups_.

Referenced by processHistoryID().

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.size();
   }

auto art::Principal::tryNextSecondaryFile ( ) const

private

Definition at line 544 of file Principal.cc.

References delayedReader_, and nextSecondaryFileIdx_.

Referenced by findGroupsForProduct(), getGroupTryAllFiles(), getMatchingSequence(), and processHistoryID().

   {
     return delayedReader_->readFromSecondaryFile(nextSecondaryFileIdx_);
   }

void art::Principal::updateSeenRanges ( RangeSet const & rs )

protected

Definition at line 707 of file Principal.cc.

References rangeSet_.

Referenced by processHistoryID().

   {
     rangeSet_ = rs;
   }

Member Data Documentation

BranchType art::Principal::branchType_ {}

private

Definition at line 230 of file Principal.h.

Referenced by branchType(), createGroupsForProducedProducts(), getByProductID(), makeInserter(), and put().

std::unique_ptr<DelayedReader> art::Principal::delayedReader_ {nullptr}

private

Definition at line 250 of file Principal.h.

Referenced by fillGroup(), Principal(), and tryNextSecondaryFile().

std::atomic<bool> art::Principal::enableLookupOfProducedProducts_ {false}

private

Definition at line 238 of file Principal.h.

Referenced by enableLookupOfProducedProducts(), findGroupsForProduct(), getMatchingSequence(), getProductDescription(), and producedInProcess().

std::recursive_mutex art::Principal::groupMutex_ {}

mutableprivate

Definition at line 241 of file Principal.h.

Referenced by begin(), cbegin(), cend(), end(), fillGroup(), getGroupLocal(), readImmediate(), and size().

GroupCollection art::Principal::groups_ {}

private

Definition at line 246 of file Principal.h.

Referenced by begin(), cbegin(), cend(), end(), fillGroup(), getGroupLocal(), readImmediate(), and size().

int art::Principal::nextSecondaryFileIdx_ {}

mutableprivate

Definition at line 264 of file Principal.h.

Referenced by tryNextSecondaryFile().

std::atomic<ProductTable const*> art::Principal::presentProducts_

private

Definition at line 236 of file Principal.h.

Referenced by findGroupsFromInputFile(), getProductDescription(), matchingSequenceFromInputFile(), presentFromSource(), and Principal().

ProcessConfiguration const& art::Principal::processConfiguration_

private

Definition at line 233 of file Principal.h.

Referenced by addToProcessHistory(), Principal(), and processConfiguration().

ProcessHistory art::Principal::processHistory_ {}

private

Definition at line 231 of file Principal.h.

Referenced by addToProcessHistory(), findGroups(), processHistory(), and processHistoryID().

std::atomic<bool> art::Principal::processHistoryModified_ {false}

private

Definition at line 232 of file Principal.h.

Referenced by addToProcessHistory(), and markProcessHistoryAsModified().

std::atomic<ProductTable const*> art::Principal::producedProducts_ {nullptr}

private

Definition at line 237 of file Principal.h.

Referenced by createGroupsForProducedProducts(), findGroupsForProduct(), getMatchingSequence(), getProductDescription(), and producedInProcess().

RangeSet art::Principal::rangeSet_ {RangeSet::invalid()}

private

Definition at line 266 of file Principal.h.

Referenced by seenRanges(), and updateSeenRanges().

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

mutableprivate

Definition at line 260 of file Principal.h.

Referenced by findGroupsForProduct(), getGroupTryAllFiles(), getMatchingSequence(), and getProductDescription().

The documentation for this class was generated from the following files:

art/Framework/Principal/Principal.h
art/Framework/Principal/Principal.cc

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation