#include "EventPrincipal.h"

Inheritance diagram for art::EventPrincipal:

Public Types
using	Auxiliary = EventAuxiliary

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
	~EventPrincipal ()

	EventPrincipal (EventAuxiliary const &aux, ProcessConfiguration const &pc, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< DelayedReader > &&rtrv=std::make_unique< NoDelayedReader >(), bool lastInSubRun=false)

Event	makeEvent (ModuleContext const &mc)

Event	makeEvent (ModuleContext const &mc) const

EventAuxiliary const &	eventAux () const

EventID const &	eventID () const

EventNumber_t	event () const

SubRunNumber_t	subRun () const

RunNumber_t	run () const

Timestamp const &	time () const

SubRunPrincipal const &	subRunPrincipal () const

void	setSubRunPrincipal (cet::exempt_ptr< SubRunPrincipal const > srp)

EventAuxiliary::ExperimentType	ExperimentType () const

bool	isReal () const

bool	isLastInSubRun () const

void	createGroupsForProducedProducts (ProductTables const &producedProducts)

void	refreshProcessHistoryID ()

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	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

Static Public Attributes
static constexpr BranchType	branch_type = Auxiliary::branch_type

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

void	fillGroup (BranchDescription const &)

void	setProcessHistoryIDcombined (ProcessHistoryID const &)

void	updateSeenRanges (RangeSet const &rs)

Private Attributes
cet::exempt_ptr< SubRunPrincipal const >	subRunPrincipal_ {nullptr}

EventAuxiliary	aux_

bool	lastInSubRun_

Detailed Description

Definition at line 17 of file EventPrincipal.h.

Member Typedef Documentation

using art::EventPrincipal::Auxiliary = EventAuxiliary

Definition at line 19 of file EventPrincipal.h.

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

inherited

Definition at line 52 of file Principal.h.

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

inherited

Definition at line 51 of file Principal.h.

Member Enumeration Documentation

enum art::Principal::allowed_processes

stronginherited

Enumerator
current_process
input_source
all

Definition at line 53 of file Principal.h.

53 { current_process, input_source, all };

Constructor & Destructor Documentation

art::EventPrincipal::~EventPrincipal ( )

default

art::EventPrincipal::EventPrincipal	(	EventAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< DelayedReader > &&	rtrv = `std::make_unique<NoDelayedReader>()`,
		bool	lastInSubRun = `false`
	)

Definition at line 10 of file EventPrincipal.cc.

References aux_, art::InEvent, lastInSubRun_, and art::EventAuxiliary::processHistoryID().

     : Principal{InEvent,
                 pc,
                 presentProducts,
                 aux.processHistoryID(),
                 std::move(reader)}
     , aux_{aux}
     , lastInSubRun_{lastInSubRun}
   {}

Member Function Documentation

void art::Principal::addToProcessHistory ( )

inherited

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(), art::Principal::processConfiguration_, art::Principal::processHistory_, art::Principal::processHistoryModified_, and art::ProcessConfiguration::processName().

Referenced by art::Principal::createGroupsForProducedProducts(), and art::Principal::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

inherited

Definition at line 270 of file Principal.cc.

References art::Principal::groupMutex_, and art::Principal::groups_.

Referenced by art::Principal::processHistoryID().

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

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

inherited

Definition at line 298 of file Principal.cc.

References art::Principal::getGroupLocal().

Referenced by art::markAncestors(), and art::Principal::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

inherited

Definition at line 807 of file Principal.cc.

References art::Principal::branchType_.

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

   {
     return branchType_;
   }

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

inherited

Definition at line 277 of file Principal.cc.

References art::Principal::groupMutex_, and art::Principal::groups_.

Referenced by art::Principal::processHistoryID().

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

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

inherited

Definition at line 291 of file Principal.cc.

References art::Principal::groupMutex_, and art::Principal::groups_.

Referenced by art::Principal::processHistoryID().

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

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

Definition at line 115 of file EventPrincipal.cc.

References art::Principal::createGroupsForProducedProducts(), and refreshProcessHistoryID().

   {
     Principal::createGroupsForProducedProducts(producedProducts);
     refreshProcessHistoryID();
   }

void art::Principal::enableLookupOfProducedProducts ( )

inherited

Definition at line 220 of file Principal.cc.

References art::Principal::enableLookupOfProducedProducts_.

   {
     enableLookupOfProducedProducts_ = true;
   }

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

inherited

Definition at line 284 of file Principal.cc.

References art::Principal::groupMutex_, and art::Principal::groups_.

Referenced by art::Principal::processHistoryID().

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

EventNumber_t art::EventPrincipal::event ( ) const

Definition at line 51 of file EventPrincipal.cc.

References aux_, art::EventID::event(), and art::EventAuxiliary::id().

   {
     return aux_.id().event();
   }

EventAuxiliary const & art::EventPrincipal::eventAux ( ) const

Definition at line 39 of file EventPrincipal.cc.

References aux_.

   {
     return aux_;
   }

EventID const & art::EventPrincipal::eventID ( ) const

Definition at line 45 of file EventPrincipal.cc.

References aux_, and art::EventAuxiliary::id().

Referenced by art::OutputModule::doWriteEvent(), art::Event::id(), art::Source< T >::throwIfInsane_(), and art::EndPathExecutor::writeEvent().

   {
     return aux_.id();
   }

EventAuxiliary::ExperimentType art::EventPrincipal::ExperimentType ( ) const

Definition at line 81 of file EventPrincipal.cc.

References aux_, and art::EventAuxiliary::experimentType().

Referenced by art::Event::experimentType().

   {
     return aux_.experimentType();
   }

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

protectedinherited

Definition at line 137 of file Principal.cc.

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

Referenced by art::Principal::createGroupsForProducedProducts(), and art::Principal::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);
   }

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

inherited

Definition at line 506 of file Principal.cc.

References art::Principal::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

inherited

Definition at line 839 of file Principal.cc.

References art::Principal::branchType_, art::Principal::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

inherited

Definition at line 488 of file Principal.cc.

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

Referenced by art::Principal::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);
   }

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

inherited

Definition at line 750 of file Principal.cc.

References art::Principal::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()};
   }

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

inherited

Definition at line 520 of file Principal.cc.

References art::Principal::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

inherited

Definition at line 534 of file Principal.cc.

References art::Principal::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

inherited

Definition at line 550 of file Principal.cc.

References art::ProcessTag::current_process_search_allowed(), art::Principal::enableLookupOfProducedProducts_, art::Principal::findGroups(), art::ProcessTag::input_source_search_allowed(), art::Principal::matchingSequenceFromInputFile(), art::Principal::producedProducts_, art::Principal::secondaryPrincipals_, and art::Principal::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

inherited

Definition at line 779 of file Principal.cc.

References art::Principal::enableLookupOfProducedProducts_, art::Principal::presentProducts_, art::Principal::producedProducts_, and art::Principal::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;
   }

bool art::EventPrincipal::isLastInSubRun ( ) const

Definition at line 87 of file EventPrincipal.cc.

References lastInSubRun_.

Referenced by art::EndPathExecutor::writeEvent().

   {
     return lastInSubRun_;
   }

bool art::EventPrincipal::isReal ( ) const

Definition at line 75 of file EventPrincipal.cc.

References aux_, and art::EventAuxiliary::isRealData().

Referenced by art::Event::isRealData().

   {
     return aux_.isRealData();
   }

Event art::EventPrincipal::makeEvent ( ModuleContext const & mc )

Definition at line 27 of file EventPrincipal.cc.

References art::Principal::makeInserter().

Referenced by art::detail::Producer::doEvent(), art::detail::Filter::doEvent(), art::ResultsProducer::doEvent(), art::OutputModule::doEvent(), art::ProducingService::doPostReadEvent(), and art::TriggerPathsExecutor::process_event().

   {
     return Event{*this, mc, makeInserter(mc)};
   }

Event art::EventPrincipal::makeEvent ( ModuleContext const & mc ) const

Definition at line 33 of file EventPrincipal.cc.

   {
     return Event{*this, mc};
   }

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

protectedinherited

Definition at line 813 of file Principal.cc.

References art::Principal::branchType_.

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

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

void art::Principal::markProcessHistoryAsModified ( )

inherited

Definition at line 170 of file Principal.cc.

References art::Principal::processHistoryModified_.

   {
     processHistoryModified_ = true;
   }

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

inherited

Definition at line 257 of file Principal.cc.

References art::Principal::processConfiguration_.

   {
     return processConfiguration_;
   }

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

inherited

Definition at line 247 of file Principal.cc.

References art::Principal::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

inlineinherited

Definition at line 148 of file Principal.h.

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

     {
       return processHistory_.id();
     }

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

inherited

Definition at line 177 of file Principal.cc.

References art::Principal::getGroupTryAllFiles().

Referenced by art::Principal::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

inherited

Definition at line 189 of file Principal.cc.

References art::Principal::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
	)

inherited

Definition at line 713 of file Principal.cc.

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

Referenced by art::ProductInserter::commitProducts(), and art::Principal::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

inherited

Definition at line 226 of file Principal.cc.

References art::Principal::groupMutex_, art::Principal::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();
     }
   }

void art::EventPrincipal::refreshProcessHistoryID ( )

Definition at line 109 of file EventPrincipal.cc.

References aux_, art::Principal::processHistoryID(), and art::EventAuxiliary::setProcessHistoryID().

Referenced by createGroupsForProducedProducts().

   {
     aux_.setProcessHistoryID(processHistoryID());
   }

RunNumber_t art::EventPrincipal::run ( ) const

Definition at line 63 of file EventPrincipal.cc.

References aux_, art::EventAuxiliary::id(), and art::EventID::run().

   {
     return aux_.id().run();
   }

RangeSet art::Principal::seenRanges ( ) const

inherited

Definition at line 701 of file Principal.cc.

References art::Principal::rangeSet_.

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

   {
     return rangeSet_;
   }

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

protectedinherited

Referenced by art::Principal::processHistoryID().

void art::EventPrincipal::setSubRunPrincipal ( cet::exempt_ptr< SubRunPrincipal const > srp )

Definition at line 103 of file EventPrincipal.cc.

References subRunPrincipal_.

   {
     subRunPrincipal_ = srp;
   }

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

inherited

Definition at line 263 of file Principal.cc.

References art::Principal::groupMutex_, and art::Principal::groups_.

Referenced by art::Principal::processHistoryID().

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

SubRunNumber_t art::EventPrincipal::subRun ( ) const

Definition at line 57 of file EventPrincipal.cc.

References aux_, art::EventAuxiliary::id(), and art::EventID::subRun().

   {
     return aux_.id().subRun();
   }

SubRunPrincipal const & art::EventPrincipal::subRunPrincipal ( ) const

Definition at line 93 of file EventPrincipal.cc.

References art::errors::NullPointerError, and subRunPrincipal_.

   {
     if (subRunPrincipal_.get() == nullptr) {
       throw Exception(errors::NullPointerError)
         << "Tried to obtain a NULL subRunPrincipal.\n";
     }
     return *subRunPrincipal_;
   }