#include "Group.h"

Inheritance diagram for art::Group:

Public Member Functions
	Group ()=default

bool	productUnavailable () const

bool	isReady () const override

EDProduct const *	getIt () const override

EDProduct const *	anyProduct () const override

EDProduct const *	uniqueProduct () const override

EDProduct const *	uniqueProduct (TypeID const &) const override

cet::exempt_ptr< ProductProvenance const >	productProvenancePtr () const

BranchDescription const &	productDescription () const

std::string const &	moduleLabel () const

std::string const &	productInstanceName () const

std::string const &	processName () const

ProductStatus	status () const

void	setResolvers (BranchMapper const &bm, DelayedReader const &dr)

bool	resolveProduct (TypeID const &) const override

bool	resolveProductIfAvailable (TypeID const &) const override

void	write (std::ostream &os) const

ProductID const &	productID () const

TypeID const &	producedWrapperType () const

virtual void	removeCachedProduct () const

RangeSet const &	rangeOfValidity () const

Protected Member Functions
	Group (BranchDescription const &pd, ProductID const &pid, RangeSet &&rs, art::TypeID const &wrapper_type, std::unique_ptr< EDProduct > &&edp=nullptr, cet::exempt_ptr< Worker > productProducer=cet::exempt_ptr< Worker >{})

	Group (BranchDescription const &pd, ProductID const &pid, RangeSet &&rs, cet::exempt_ptr< Worker > productProducer, art::TypeID const &wrapper_type)

	Group (BranchDescription const &pd, ProductID const &pid, RangeSet &&rs, std::unique_ptr< EDProduct > &&edp, art::TypeID const &wrapper_type)

std::unique_ptr< EDProduct >	obtainDesiredProduct (TypeID const &) const

void	setProduct (std::unique_ptr< EDProduct > &&prod) const

void	throwResolveLogicError (TypeID const &wanted_wrapper_type) const

Private Member Functions
bool	dropped () const

Private Attributes
TypeID	wrapperType_ {}

cet::exempt_ptr< BranchMapper const >	ppResolver_ {nullptr}

cet::exempt_ptr< DelayedReader const >	productResolver_ {nullptr}

std::unique_ptr< EDProduct >	product_ {nullptr}

cet::exempt_ptr< BranchDescription const >	branchDescription_ {nullptr}

ProductID	pid_ {}

cet::exempt_ptr< Worker >	productProducer_ {nullptr}

RangeSet	rangeOfValidity_ {RangeSet::invalid()}

Friends
template<typename... ARGS>
std::unique_ptr< Group >	gfactory::detail::make_group (BranchDescription const &, ARGS &&...args)

Detailed Description

Definition at line 34 of file Group.h.

Constructor & Destructor Documentation

art::Group::Group ( )

default

art::Group::Group	(	BranchDescription const &	pd,
		ProductID const &	pid,
		RangeSet &&	rs,
		art::TypeID const &	wrapper_type,
		std::unique_ptr< EDProduct > &&	edp = `nullptr`,
		cet::exempt_ptr< Worker >	productProducer = `cet::exempt_ptr<Worker>{}`
	)

inlineprotected

Definition at line 49 of file Group.h.

References branchDescription_, pid_, product_, productProducer_, rangeOfValidity_, and wrapperType_.

                                                                        {})
       : wrapperType_{wrapper_type}
       , product_{std::move(edp)}
       , branchDescription_{&pd}
       , pid_{pid}
       , productProducer_{productProducer}
       , rangeOfValidity_{std::move(rs)}
     {}

art::Group::Group	(	BranchDescription const &	pd,
		ProductID const &	pid,
		RangeSet &&	rs,
		cet::exempt_ptr< Worker >	productProducer,
		art::TypeID const &	wrapper_type
	)

inlineprotected

Definition at line 63 of file Group.h.

68 : Group{pd, pid, std::move(rs), wrapper_type, nullptr, productProducer}

69 {}

art::Group::Group

Group()=default

pid

Definition: Chi2ParticleID_module.cc:41

art::Group::Group	(	BranchDescription const &	pd,
		ProductID const &	pid,
		RangeSet &&	rs,
		std::unique_ptr< EDProduct > &&	edp,
		art::TypeID const &	wrapper_type
	)

inlineprotected

Definition at line 71 of file Group.h.

References productUnavailable().

76 : Group{pd, pid, std::move(rs), wrapper_type, std::move(edp)}

77 {}

art::Group::Group

Group()=default

pid

Definition: Chi2ParticleID_module.cc:41

Member Function Documentation

EDProduct const* art::Group::anyProduct ( ) const

inlineoverridevirtual

Implements art::EDProductGetter.

Definition at line 97 of file Group.h.

References product_.

Referenced by art::AssnsGroup::anyProduct(), and art::detail::PrincipalProcessor< DETAIL >::operator()().

     {
       return product_.get();
     }

bool art::Group::dropped ( ) const

private

Definition at line 132 of file Group.cc.

References branchDescription_.

Referenced by productUnavailable(), rangeOfValidity(), and status().

 {
   assert(branchDescription_);
   return branchDescription_->dropped();
 }

EDProduct const* art::Group::getIt ( ) const

inlineoverridevirtual

Implements art::EDProductGetter.

Definition at line 90 of file Group.h.

References producedWrapperType(), product_, and resolveProductIfAvailable().

     {
       resolveProductIfAvailable(producedWrapperType());
       return product_.get();
     }

bool art::Group::isReady ( ) const

inlineoverridevirtual

Implements art::EDProductGetter.

Definition at line 84 of file Group.h.

     {
       return true;
     }

std::string const& art::Group::moduleLabel ( ) const

inline

Definition at line 123 of file Group.h.

References branchDescription_.

     {
       return branchDescription_->moduleLabel();
     }

std::unique_ptr< art::EDProduct > art::Group::obtainDesiredProduct ( TypeID const & wanted_wrapper_type ) const

protected

Definition at line 76 of file Group.cc.

References productDescription(), productResolver_, and rangeOfValidity_.

Referenced by rangeOfValidity(), and resolveProductIfAvailable().

 {
   BranchKey const bk{productDescription()};
   return productResolver_->getProduct(
     bk, wanted_wrapper_type, rangeOfValidity_);
 }

std::string const& art::Group::processName ( ) const

inline

Definition at line 135 of file Group.h.

References branchDescription_, and status().

     {
       return branchDescription_->processName();
     }

TypeID const& art::Group::producedWrapperType ( ) const

inline

Definition at line 162 of file Group.h.

References removeCachedProduct(), and wrapperType_.

Referenced by getIt(), art::detail::PrincipalProcessor< DETAIL >::operator()(), art::AssnsGroup::resolveProductIfAvailable(), and art::AssnsGroupWithData::resolveProductIfAvailable().

     {
       return wrapperType_;
     }

BranchDescription const& art::Group::productDescription ( ) const

inline

Definition at line 117 of file Group.h.

References branchDescription_.

Referenced by obtainDesiredProduct(), and resolveProduct().

     {
       return *branchDescription_;
     }

ProductID const& art::Group::productID ( ) const

inline

Definition at line 156 of file Group.h.

References pid_.

     {
       return pid_;
     };

std::string const& art::Group::productInstanceName ( ) const

inline

Definition at line 129 of file Group.h.

References branchDescription_.

     {
       return branchDescription_->productInstanceName();
     }

cet::exempt_ptr< art::ProductProvenance const > art::Group::productProvenancePtr ( ) const

Definition at line 96 of file Group.cc.

References branchDescription_, and ppResolver_.

Referenced by art::detail::PrincipalProcessor< DETAIL >::operator()(), resolveProduct(), status(), and uniqueProduct().

 {
   if (!ppResolver_) {
     return cet::exempt_ptr<ProductProvenance const>{};
   }
   return ppResolver_->branchToProductProvenance(
     branchDescription_->productID());
 }

bool art::Group::productUnavailable ( ) const

Definition at line 84 of file Group.cc.

References dropped(), art::productstatus::present(), status(), and art::productstatus::unknown().

Referenced by Group(), resolveProduct(), art::AssnsGroup::resolveProductIfAvailable(), art::AssnsGroupWithData::resolveProductIfAvailable(), and resolveProductIfAvailable().

 {
   if (dropped()) {
     return true;
   }
   if (productstatus::unknown(status())) {
     return false;
   }
   return !productstatus::present(status());
 }

RangeSet const& art::Group::rangeOfValidity ( ) const

inline

Definition at line 170 of file Group.h.

References dropped(), obtainDesiredProduct(), rangeOfValidity_, setProduct(), and throwResolveLogicError().

     {
       return rangeOfValidity_;
     }

void art::Group::removeCachedProduct ( ) const

virtual

Reimplemented in art::AssnsGroupWithData, and art::AssnsGroup.

Definition at line 106 of file Group.cc.

References branchDescription_, and product_.

Referenced by producedWrapperType(), and art::AssnsGroup::removeCachedProduct().

 {
   // This check should already have been done by the surrounding art
   // code, therefore this is a precondition and valid for an assertion
   // rather than a runtime check and throw.
   assert(!(branchDescription_ && branchDescription_->produced()));
   product_.reset();
 }

bool art::Group::resolveProduct ( TypeID const & wanted_wrapper_type ) const

overridevirtual

Implements art::EDProductGetter.

Definition at line 45 of file Group.cc.

References e, productDescription(), art::errors::ProductNotFound, productProvenancePtr(), productUnavailable(), and resolveProductIfAvailable().

Referenced by art::detail::PrincipalProcessor< DETAIL >::operator()(), and setResolvers().

 {
   if (!productUnavailable()) {
     return resolveProductIfAvailable(wanted_wrapper_type);
   }
   art::Exception e{errors::ProductNotFound, "InaccessibleProduct"};
   e << "resolveProduct: product is not accessible\n"
     << productDescription() << '\n';
   if (productProvenancePtr()) {
     e << *productProvenancePtr() << '\n';
   }
   throw e;
 }

bool art::Group::resolveProductIfAvailable ( TypeID const & wanted_wrapper_type ) const

overridevirtual

Implements art::EDProductGetter.

Definition at line 60 of file Group.cc.

References obtainDesiredProduct(), product_, productUnavailable(), setProduct(), throwResolveLogicError(), and wrapperType_.

Referenced by getIt(), resolveProduct(), art::AssnsGroup::resolveProductIfAvailable(), and setResolvers().

 {
   if (wanted_wrapper_type != wrapperType_) {
     throwResolveLogicError(wanted_wrapper_type);
   }
   bool result = product_.get();
   if (!(result || productUnavailable())) {
     std::unique_ptr<EDProduct> edp{obtainDesiredProduct(wanted_wrapper_type)};
     if ((result = edp.get())) {
       setProduct(std::move(edp));
     }
   }
   return result;
 }

void art::Group::setProduct ( std::unique_ptr< EDProduct > && prod ) const

protected

Definition at line 116 of file Group.cc.

References product_.

Referenced by rangeOfValidity(), and resolveProductIfAvailable().

 {
   assert(!product_.get());
   product_ = std::move(prod);
 }

void art::Group::setResolvers	(	BranchMapper const &	bm,
		DelayedReader const &	dr
	)

inline

Definition at line 143 of file Group.h.

References ppResolver_, productResolver_, resolveProduct(), resolveProductIfAvailable(), and write().

     {
       ppResolver_.reset(&bm);
       productResolver_.reset(&dr);
     }

art::ProductStatus art::Group::status ( ) const

Definition at line 14 of file Group.cc.

References art::productstatus::dropped(), dropped(), art::productstatus::neverCreated(), art::productstatus::present(), product_, productProvenancePtr(), and art::productstatus::unknown().

Referenced by processName(), and productUnavailable().

 {
   if (dropped()) {
     return productstatus::dropped();
   }
   cet::exempt_ptr<ProductProvenance const> pp(productProvenancePtr());
   if (!pp) {
     // No provenance, must be new.
     if (product_.get()) {
       if (product_->isPresent()) {
         return productstatus::present();
       }
       return productstatus::neverCreated();
     }
     return productstatus::unknown();
   }
   if (product_.get()) {
     // Product has already been delay read, use the present flag
     // from the wrapper.
     // FIXME: Old CMS note said backward compatibility only?
     if (product_->isPresent()) {
       pp->setPresent();
     } else {
       pp->setNotPresent();
     }
   }
   // Not new, and not yet read, use the status from the provenance.
   return pp->productStatus();
 }

void art::Group::throwResolveLogicError ( TypeID const & wanted_wrapper_type ) const

protected

Definition at line 123 of file Group.cc.

References art::TypeID::className(), and art::errors::LogicError.

Referenced by rangeOfValidity(), art::AssnsGroup::resolveProductIfAvailable(), art::AssnsGroupWithData::resolveProductIfAvailable(), and resolveProductIfAvailable().

 {
   throw Exception(errors::LogicError, "INTERNAL ERROR: ")
     << cet::demangle_symbol(typeid(*this).name())
     << " cannot resolve wanted product of type "
     << wanted_wrapper_type.className() << ".\n";
 }

EDProduct const* art::Group::uniqueProduct ( ) const

inlineoverridevirtual

Implements art::EDProductGetter.

Definition at line 103 of file Group.h.

References product_.

Referenced by art::AssnsGroup::makePartner(), art::AssnsGroup::resolveProductIfAvailable(), and art::AssnsGroup::uniqueProduct().

     {
       return product_.get();
     }

EDProduct const* art::Group::uniqueProduct ( TypeID const & ) const

inlineoverridevirtual

Implements art::EDProductGetter.

Definition at line 109 of file Group.h.

References product_, and productProvenancePtr().

     {
       return product_.get();
     }

void art::Group::write ( std::ostream & os ) const

Definition at line 139 of file Group.cc.

References pid_.

Referenced by art::operator<<(), and setResolvers().

 {
   // This is grossly inadequate. It is also not critical for the
   // first pass.
   os << "Group for product with ID: " << pid_;
 }

Friends And Related Function Documentation

template<typename... ARGS>

std::unique_ptr<Group> gfactory::detail::make_group	(	BranchDescription const &	,
		ARGS &&...	args
	)

friend

Member Data Documentation

cet::exempt_ptr<BranchDescription const> art::Group::branchDescription_ {nullptr}

private

Definition at line 191 of file Group.h.

Referenced by dropped(), Group(), moduleLabel(), processName(), productDescription(), productInstanceName(), productProvenancePtr(), and removeCachedProduct().

ProductID art::Group::pid_ {}

mutableprivate

Definition at line 192 of file Group.h.

Referenced by Group(), productID(), and write().

cet::exempt_ptr<BranchMapper const> art::Group::ppResolver_ {nullptr}

private

Definition at line 188 of file Group.h.

Referenced by productProvenancePtr(), and setResolvers().

std::unique_ptr<EDProduct> art::Group::product_ {nullptr}

mutableprivate

Definition at line 190 of file Group.h.

Referenced by anyProduct(), getIt(), Group(), removeCachedProduct(), resolveProductIfAvailable(), setProduct(), status(), and uniqueProduct().

cet::exempt_ptr<Worker> art::Group::productProducer_ {nullptr}

private

Definition at line 193 of file Group.h.

Referenced by Group().

cet::exempt_ptr<DelayedReader const> art::Group::productResolver_ {nullptr}

private

Definition at line 189 of file Group.h.

Referenced by obtainDesiredProduct(), and setResolvers().

RangeSet art::Group::rangeOfValidity_ {RangeSet::invalid()}

mutableprivate

Definition at line 194 of file Group.h.

Referenced by Group(), obtainDesiredProduct(), and rangeOfValidity().

TypeID art::Group::wrapperType_ {}

private

Definition at line 187 of file Group.h.

Referenced by Group(), producedWrapperType(), and resolveProductIfAvailable().

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

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation