art::ProductInserter Class Reference

#include "ProductInserter.h"

Classes
struct	PMValue

Public Member Functions
	~ProductInserter ()
	ProductInserter (BranchType bt, Principal &p, ModuleContext const &mc)
	ProductInserter (ProductInserter const &)=delete
ProductInserter &	operator= (ProductInserter const &)=delete
	ProductInserter (ProductInserter &&)=default
ProductInserter &	operator= (ProductInserter &&)=default
template<typename PROD >
PutHandle< PROD >	put (std::unique_ptr< PROD > &&edp, std::string const &instance={})
template<typename PROD >
PutHandle< PROD >	put (std::unique_ptr< PROD > &&edp, std::string const &instance, RangeSet const &rs)
void	commitProducts ()
void	commitProducts (bool checkProducts, std::map< TypeLabel, BranchDescription > const *expectedProducts, std::vector< ProductID > retrievedPIDs)

Private Member Functions
BranchDescription const &	getProductDescription_ (TypeID const &type, std::string const &instance, bool const alwaysEnableLookupOfProducedProducts=false) const
EDProductGetter const *	productGetter_ (ProductID id) const
Provenance	provenance_ (ProductID id) const

Private Attributes
std::unique_ptr< std::recursive_mutex >	mutex_
BranchType	branchType_
Principal *	principal_
ModuleDescription const *	md_
std::map< TypeLabel, PMValue >	putProducts_ {}

Detailed Description

Definition at line 37 of file ProductInserter.h.

Constructor & Destructor Documentation

art::ProductInserter::~ProductInserter ( )

default

art::ProductInserter::ProductInserter ( BranchType  bt, Principal &  p, ModuleContext const &  mc  )

explicit

Definition at line 37 of file ProductInserter.cc.

References md_, and principal_.

    : branchType_{bt}, principal_{&principal}, md_{&mc.moduleDescription()}
  {}

art::ProductInserter::ProductInserter ( ProductInserter const &  )

delete

art::ProductInserter::ProductInserter ( ProductInserter &&  )

default

Member Function Documentation

void art::ProductInserter::commitProducts

(

)

Definition at line 87 of file ProductInserter.cc.

References branchType_, art::RangeSet::invalid(), mutex_, art::productstatus::present(), principal_, art::Principal::put(), putProducts_, art::detail::range_sets_supported(), and util::values().

  {
    std::lock_guard lock{*mutex_};
    for (auto&& [product, pd, range_set] :
         putProducts_ | ::ranges::views::values) {
      auto pp = make_unique<ProductProvenance const>(pd.productID(),
                                                     productstatus::present());
      auto rs = detail::range_sets_supported(branchType_) ?
                  make_unique<RangeSet>(std::move(range_set)) :
                  make_unique<RangeSet>(RangeSet::invalid());
      principal_->put(pd, std::move(pp), std::move(product), std::move(rs));
    }
    putProducts_.clear();
  }

void art::ProductInserter::commitProducts	(	bool	checkProducts,
		std::map< TypeLabel, BranchDescription > const *	expectedProducts,
		std::vector< ProductID >	retrievedPIDs
	)

Definition at line 44 of file ProductInserter.cc.

References branchType_, art::InEvent, art::RangeSet::invalid(), art::errors::LogicError, mutex_, art::productstatus::present(), principal_, art::Principal::put(), putProducts_, and util::values().

  {
    assert(branchType_ == InEvent);
    std::lock_guard lock{*mutex_};
    if (checkProducts) {
      vector<string> missing;
      for (auto const& [typeLabel, bd] : *expectedProducts) {
        if (putProducts_.find(typeLabel) != putProducts_.cend()) {
          continue;
        }
        ostringstream desc;
        desc << bd;
        missing.emplace_back(desc.str());
      }
      if (!missing.empty()) {
        ostringstream errmsg;
        HorizontalRule rule{25};
        errmsg << "The following products have been declared with 'produces',\n"
               << "but they have not been placed onto the event:\n"
               << rule('=') << '\n';
        for (auto const& desc : missing) {
          errmsg << desc << rule('=') << '\n';
        }
        throw Exception{errors::LogicError, "ProductInserter::checkPutProducts"}
          << errmsg.str();
      }
    }

    for (auto&& [product, pd, rs] : putProducts_ | ::ranges::views::values) {
      auto pp = make_unique<ProductProvenance const>(
        pd.productID(), productstatus::present(), retrievedPIDs);
      principal_->put(pd,
                      std::move(pp),
                      std::move(product),
                      make_unique<RangeSet>(RangeSet::invalid()));
    }
    putProducts_.clear();
  }

BranchDescription const & art::ProductInserter::getProductDescription_ ( TypeID const &  type, std::string const &  instance, bool const  alwaysEnableLookupOfProducedProducts = false  ) const

private

Definition at line 103 of file ProductInserter.cc.

References branchType_, art::canonicalProductName(), art::TypeID::className(), art::TypeID::friendlyClassName(), art::Principal::getProductDescription(), instance, md_, art::ModuleDescription::moduleLabel(), mutex_, principal_, art::ModuleDescription::processName(), and art::errors::ProductRegistrationFailure.

Referenced by put().

  {
    std::lock_guard lock{*mutex_};
    auto const product_name = canonicalProductName(type.friendlyClassName(),
                                                   md_->moduleLabel(),
                                                   instance,
                                                   md_->processName());
    ProductID const pid{product_name};
    auto bd = principal_->getProductDescription(
      pid, alwaysEnableLookupOfProducedProducts);
    if (!bd || (bd->producedClassName() != type.className())) {
      // Either we did not find the product, or the product we
      // did find does not match (which can happen with Assns
      // since Assns(A,B) and Assns(B,A) have the same ProductID
      // but not the same class name.
      throw Exception(errors::ProductRegistrationFailure,
                      "ProductInserter::getProductDescription_: error while "
                      "trying to retrieve product description:\n")
        << "No product is registered for\n"
        << "  process name:                '" << md_->processName() << "'\n"
        << "  module label:                '" << md_->moduleLabel() << "'\n"
        << "  product class name:          '" << type.className() << "'\n"
        << "  product friendly class name: '" << type.friendlyClassName()
        << "'\n"
        << "  product instance name:       '" << instance << "'\n"
        << "  branch type:                 '" << branchType_ << "'\n";
    }
    // The description object is owned by either the source or the
    // event processor, whose lifetimes exceed that of the
    // ProductInserter object.  It is therefore safe to dereference.
    return *bd;
  }

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

delete

ProductInserter& art::ProductInserter::operator= ( ProductInserter &&  )

default

EDProductGetter const * art::ProductInserter::productGetter_ ( ProductID  id ) const

private

Definition at line 140 of file ProductInserter.cc.

References principal_, and art::Principal::productGetter().

Referenced by put().

  {
    return principal_->productGetter(id);
  }

Provenance art::ProductInserter::provenance_ ( ProductID  id ) const

private

Definition at line 146 of file ProductInserter.cc.

References principal_, and art::Principal::provenance().

  {
    return principal_->provenance(id);
  }

template<typename PROD >

PutHandle< PROD > art::ProductInserter::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance = {}
	)

Definition at line 102 of file ProductInserter.h.

References art::RangeSet::invalid().

  {
    return put(std::move(edp), instance, RangeSet::invalid());
  }

template<typename PROD >

PutHandle< PROD > art::ProductInserter::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		RangeSet const &	rs
	)

Definition at line 109 of file ProductInserter.h.

References getProductDescription_(), art::ProductID::invalid(), md_, mutex_, art::errors::NullPointerError, art::ProductInserter::PMValue::product, productGetter_(), art::errors::ProductPutFailure, putProducts_, and art::detail::type_label_for().

  {
    TypeID const tid{typeid(PROD)};
    if (!edp) {
      throw Exception(errors::NullPointerError)
        << "A null unique_ptr was passed to 'put'.\n"
        << "The pointer is of type " << tid << ".\n"
        << "The specified productInstanceName was '" << instance << "'.\n";
    }

    std::lock_guard lock{*mutex_};
    auto const& bd = getProductDescription_(tid, instance, true);
    assert(bd.productID() != ProductID::invalid());
    auto const typeLabel =
      detail::type_label_for(tid, instance, SupportsView<PROD>::value, *md_);
    auto wp = std::make_unique<Wrapper<PROD>>(std::move(edp));

    // Mind the product ownership!  The wrapper is the final resting
    // place of the product before it is taken out of memory.
    cet::exempt_ptr<PROD const> product{wp->product()};
    auto result =
      putProducts_.try_emplace(typeLabel, PMValue{std::move(wp), bd, rs})
        .second;
    if (!result) {
      constexpr cet::HorizontalRule rule{30};
      throw Exception(errors::ProductPutFailure)
        << "Attempt to put multiple products with the following descriptions.\n"
        << "Each product must be unique.\n"
        << rule('=') << '\n'
        << bd << rule('=') << '\n';
    }
    return PutHandle{
      product.get(), productGetter_(bd.productID()), bd.productID()};
  }

Member Data Documentation

BranchType art::ProductInserter::branchType_

private

Definition at line 86 of file ProductInserter.h.

Referenced by commitProducts(), and getProductDescription_().

ModuleDescription const* art::ProductInserter::md_

private

Definition at line 92 of file ProductInserter.h.

Referenced by getProductDescription_(), ProductInserter(), and put().

std::unique_ptr<std::recursive_mutex> art::ProductInserter::mutex_

mutableprivate

Initial value:

{
      std::make_unique<std::recursive_mutex>()}

Definition at line 82 of file ProductInserter.h.

Referenced by commitProducts(), getProductDescription_(), and put().

Principal* art::ProductInserter::principal_

private

Definition at line 89 of file ProductInserter.h.

Referenced by commitProducts(), getProductDescription_(), productGetter_(), ProductInserter(), and provenance_().

std::map<TypeLabel, PMValue> art::ProductInserter::putProducts_ {}

private

Definition at line 95 of file ProductInserter.h.

Referenced by commitProducts(), and put().

---

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

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