art::ResultsPrincipal Class Reference

#include "ResultsPrincipal.h"

Inheritance diagram for art::ResultsPrincipal:

Public Types
using	Auxiliary = ResultsAuxiliary
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
	~ResultsPrincipal ()
	ResultsPrincipal (ResultsAuxiliary const &, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >())
Results	makeResults (ModuleContext const &mc)
Results	makeResults (ModuleContext const &mc) const
ResultsAuxiliary const &	resultsAux () const
void	createGroupsForProducedProducts (ProductTables const &producedProducts)
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 = ResultsAuxiliary::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
ResultsAuxiliary	aux_

Detailed Description

Definition at line 25 of file ResultsPrincipal.h.

Member Typedef Documentation

using art::ResultsPrincipal::Auxiliary = ResultsAuxiliary

Definition at line 27 of file ResultsPrincipal.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.

{ current_process, input_source, all };

Constructor & Destructor Documentation

art::ResultsPrincipal::~ResultsPrincipal ( )

default

art::ResultsPrincipal::ResultsPrincipal	(	ResultsAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< DelayedReader > &&	reader = std::make_unique<NoDelayedReader>()
	)

Definition at line 9 of file ResultsPrincipal.cc.

References aux_, art::InResults, and art::ResultsAuxiliary::processHistoryID().

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

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::ResultsPrincipal::createGroupsForProducedProducts

(

ProductTables const &

producedProducts

)

Definition at line 42 of file ResultsPrincipal.cc.

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

  {
    Principal::createGroupsForProducedProducts(producedProducts);
    aux_.setProcessHistoryID(processHistoryID());
  }

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();
  }

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

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

protectedinherited

Definition at line 813 of file Principal.cc.

References art::Principal::branchType_.

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

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

Results art::ResultsPrincipal::makeResults

(

ModuleContext const &

mc

)

Definition at line 24 of file ResultsPrincipal.cc.

References art::Principal::makeInserter().

Referenced by art::ResultsProducer::doReadResults(), and art::ResultsProducer::doWriteResults().

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

Results art::ResultsPrincipal::makeResults

(

ModuleContext const &

mc

)

const

Definition at line 30 of file ResultsPrincipal.cc.

  {
    return Results{*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.

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

Referenced by art::RunPrincipal::createGroupsForProducedProducts(), createGroupsForProducedProducts(), art::SubRunPrincipal::createGroupsForProducedProducts(), art::Event::processHistoryID(), and art::EventPrincipal::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();
    }
  }

ResultsAuxiliary const & art::ResultsPrincipal::resultsAux

(

)

const

Definition at line 36 of file ResultsPrincipal.cc.

References aux_.

  {
    return aux_;
  }

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().

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();
  }

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

protectedinherited

Definition at line 707 of file Principal.cc.

References art::Principal::rangeSet_.

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

  {
    rangeSet_ = rs;
  }

Member Data Documentation

ResultsAuxiliary art::ResultsPrincipal::aux_

private

Definition at line 45 of file ResultsPrincipal.h.

Referenced by createGroupsForProducedProducts(), resultsAux(), and ResultsPrincipal().

constexpr BranchType art::ResultsPrincipal::branch_type = ResultsAuxiliary::branch_type

static

Definition at line 28 of file ResultsPrincipal.h.

---

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

• art/Framework/Principal/ResultsPrincipal.h
• art/Framework/Principal/ResultsPrincipal.cc