#include <ProductResolvers.h>

Inheritance diagram for edm::MergeableInputProductResolver:

Public Member Functions
	MergeableInputProductResolver (std::shared_ptr< BranchDescription const > bd, ProductStatus iDefaultStatus)

Public Member Functions inherited from edm::DataManagingProductResolver
void	connectTo (ProductResolverBase const &, Principal const *) final

	DataManagingProductResolver (std::shared_ptr< BranchDescription const > bd, ProductStatus iDefaultStatus)

void	resetProductData_ (bool deleteEarly) override

void	resetStatus ()

Public Member Functions inherited from edm::DataManagingOrAliasProductResolver
	DataManagingOrAliasProductResolver ()

Public Member Functions inherited from edm::ProductResolverBase
BranchDescription const &	branchDescription () const

std::string const &	moduleLabel () const

ProductResolverBase &	operator= (ProductResolverBase const &)=delete

void	prefetchAsync (WaitingTaskHolder waitTask, Principal const &principal, bool skipCurrentProcess, ServiceToken const &token, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

std::string const &	processName () const

ProductID const &	productID () const

std::string const &	productInstanceName () const

ProductProvenance const *	productProvenancePtr () const

bool	productResolved () const

	ProductResolverBase ()

	ProductResolverBase (ProductResolverBase const &)=delete

TypeID	productType () const

bool	productUnavailable () const

bool	productWasDeleted () const

bool	productWasFetchedAndIsValid (bool iSkipCurrentProcess) const

Provenance const *	provenance () const

bool	provenanceAvailable () const

void	resetBranchDescription (std::shared_ptr< BranchDescription const > bd)

void	resetProductData ()

std::string const &	resolvedModuleLabel () const

Resolution	resolveProduct (Principal const &principal, bool skipCurrentProcess, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

void	retrieveAndMerge (Principal const &principal, MergeableRunProductMetadata const *mergeableRunProductMetadata) const

void	setMergeableRunProductMetadata (MergeableRunProductMetadata const *mrpm)

void	setProductID (ProductID const &pid)

void	setProductProvenanceRetriever (ProductProvenanceRetriever const *provRetriever)

virtual void	setupUnscheduled (UnscheduledConfigurator const &)

bool	singleProduct () const

StableProvenance const *	stableProvenance () const

void	unsafe_deleteProduct () const

bool	unscheduledWasNotRun () const

void	write (std::ostream &os) const

virtual	~ProductResolverBase ()

Protected Member Functions
void	mergeProduct (std::shared_ptr< WrapperBase > edp, MergeableRunProductMetadata const *) const

void	setOrMergeProduct (std::shared_ptr< WrapperBase > prod, MergeableRunProductMetadata const *mergeableRunProductMetadata) const

Protected Member Functions inherited from edm::DataManagingProductResolver
void	checkType (WrapperBase const &prod) const

ProductStatus	defaultStatus () const

ProductData const &	getProductData () const final

template<bool callResolver, typename FUNC >
ProductResolverBase::Resolution	resolveProductImpl (FUNC resolver) const

template<bool callResolver, typename FUNC >
Resolution	resolveProductImpl (FUNC resolver) const

void	setFailedStatus () const

void	setMergeableRunProductMetadataInProductData (MergeableRunProductMetadata const *)

void	setProduct (std::shared_ptr< WrapperBase > edp) const

void	setProduct (std::unique_ptr< WrapperBase > edp) const

ProductStatus	status () const

Additional Inherited Members
Public Types inherited from edm::DataManagingProductResolver
enum	ProductStatus { ProductStatus::ProductSet, ProductStatus::NotPut, ProductStatus::ResolveFailed, ProductStatus::ResolveNotRun, ProductStatus::ProductDeleted }

Detailed Description

Definition at line 106 of file ProductResolvers.h.

Constructor & Destructor Documentation

◆ MergeableInputProductResolver()

edm::MergeableInputProductResolver::MergeableInputProductResolver	(	std::shared_ptr< BranchDescription const >	bd,
		ProductStatus	iDefaultStatus
	)

inline

Definition at line 108 of file ProductResolvers.h.

109 : DataManagingProductResolver(bd, iDefaultStatus) {}

Member Function Documentation

◆ mergeProduct()

void edm::MergeableInputProductResolver::mergeProduct	(	std::shared_ptr< WrapperBase >	edp,
		MergeableRunProductMetadata const *	mergeableRunProductMetadata
	)		const

protected

Definition at line 79 of file ProductResolvers.cc.

                                                                                                               {
     // if its not mergeable and the previous read failed, go ahead and use this one
     if (status() == ProductStatus::ResolveFailed) {
       setProduct(std::move(iFrom));
       return;
     }
  
     assert(status() == ProductStatus::ProductSet);
     if (not iFrom) {
       return;
     }
  
     checkType(*iFrom);
  
     auto original = getProductData().unsafe_wrapper();
     if (original->isMergeable()) {
       if (original->isPresent() != iFrom->isPresent()) {
         throw Exception(errors::MismatchedInputFiles)
             << "Merge of Run or Lumi product failed for branch " << branchDescription().branchName() << "\n"
             << "Was trying to merge objects where one product had been put in the input file and the other had not "
                "been."
             << "\n"
             << "The solution is to drop the branch on input. Or better do not create inconsistent files\n"
             << "that need to be merged in the first place.\n";
       }
       if (original->isPresent()) {
         BranchDescription const& desc = branchDescription();
         if (mergeableRunProductMetadata == nullptr || desc.branchType() != InRun) {
           original->mergeProduct(iFrom.get());
         } else {
           MergeableRunProductMetadata::MergeDecision decision =
               mergeableRunProductMetadata->getMergeDecision(desc.processName());
           if (decision == MergeableRunProductMetadata::MERGE) {
             original->mergeProduct(iFrom.get());
           } else if (decision == MergeableRunProductMetadata::REPLACE) {
             // Note this swaps the content of the product where the
             // both products branches are present and the product is
             // also present (was put) in the branch. A module might
             // have already gotten a pointer to the product so we
             // keep those pointers valid. This does not call swap
             // on the Wrapper.
             original->swapProduct(iFrom.get());
           }
           // If the decision is IGNORE, do nothing
         }
       }
       // If both have isPresent false, do nothing
  
     } else if (original->hasIsProductEqual()) {
       if (original->isPresent() && iFrom->isPresent()) {
         if (!original->isProductEqual(iFrom.get())) {
           auto const& bd = branchDescription();
           edm::LogError("RunLumiMerging")
               << "ProductResolver::mergeTheProduct\n"
               << "Two run/lumi products for the same run/lumi which should be equal are not\n"
               << "Using the first, ignoring the second\n"
               << "className = " << bd.className() << "\n"
               << "moduleLabel = " << bd.moduleLabel() << "\n"
               << "instance = " << bd.productInstanceName() << "\n"
               << "process = " << bd.processName() << "\n";
         }
       } else if (!original->isPresent() && iFrom->isPresent()) {
         setProduct(std::move(iFrom));
       }
       // if not iFrom->isPresent(), do nothing
     } else {
       auto const& bd = branchDescription();
       edm::LogWarning("RunLumiMerging") << "ProductResolver::mergeTheProduct\n"
                                         << "Run/lumi product has neither a mergeProduct nor isProductEqual function\n"
                                         << "Using the first, ignoring the second in merge\n"
                                         << "className = " << bd.className() << "\n"
                                         << "moduleLabel = " << bd.moduleLabel() << "\n"
                                         << "instance = " << bd.productInstanceName() << "\n"
                                         << "process = " << bd.processName() << "\n";
       if (!original->isPresent() && iFrom->isPresent()) {
         setProduct(std::move(iFrom));
       }
       // In other cases, do nothing
     }
   }

References cms::cuda::assert(), edm::ProductResolverBase::branchDescription(), edm::BranchDescription::branchName(), edm::DataManagingProductResolver::checkType(), submitPVResolutionJobs::desc, Exception, edm::MergeableRunProductMetadata::getMergeDecision(), edm::DataManagingProductResolver::getProductData(), edm::InRun, edm::MergeableRunProductMetadata::MERGE, edm::errors::MismatchedInputFiles, eostools::move(), definitions::original, edm::DataManagingProductResolver::ProductSet, edm::MergeableRunProductMetadata::REPLACE, edm::DataManagingProductResolver::ResolveFailed, edm::DataManagingProductResolver::setProduct(), edm::DataManagingProductResolver::status(), and edm::ProductData::unsafe_wrapper().

Referenced by setOrMergeProduct().

◆ setOrMergeProduct()

void edm::MergeableInputProductResolver::setOrMergeProduct	(	std::shared_ptr< WrapperBase >	prod,
		MergeableRunProductMetadata const *	mergeableRunProductMetadata
	)		const

protected

Definition at line 239 of file ProductResolvers.cc.

                                                                                                              {
     if (status() == defaultStatus()) {
       //resolveProduct has not been called or it failed
       setProduct(std::move(prod));
     } else {
       mergeProduct(std::move(prod), mergeableRunProductMetadata);
     }
   }

References edm::DataManagingProductResolver::defaultStatus(), mergeProduct(), eostools::move(), dumpMFGeometry_cfg::prod, edm::DataManagingProductResolver::setProduct(), and edm::DataManagingProductResolver::status().

Referenced by edm::PutOnReadInputProductResolver::putOrMergeProduct(), and edm::DelayedReaderInputProductResolver::retrieveAndMerge_().

Public Member Functions