#include "Group.h"

Inheritance diagram for art::Group:

Public Types
enum	grouptype { grouptype::normal = 0, grouptype::assns = 1, grouptype::assnsWithData = 2 }

Public Member Functions
	~Group ()

	Group (DelayedReader *, BranchDescription const &, std::unique_ptr< RangeSet > &&, grouptype const gt, std::unique_ptr< EDProduct > &&edp=nullptr)

EDProduct const *	getIt_ () const override

EDProduct const *	anyProduct () const

EDProduct const *	uniqueProduct () const

EDProduct const *	uniqueProduct (TypeID const &) const

bool	resolveProductIfAvailable (TypeID wanted_wrapper=TypeID{}) const

bool	tryToResolveProduct (TypeID const &)

void	removeCachedProduct ()

BranchDescription const &	productDescription () const noexcept

ProductID	productID () const

RangeSet const &	rangeOfValidity () const

bool	productAvailable () const

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

void	setProductProvenance (std::unique_ptr< ProductProvenance const > &&)

void	setProductAndProvenance (std::unique_ptr< ProductProvenance const > &&, std::unique_ptr< EDProduct > &&, std::unique_ptr< RangeSet > &&)

EDProduct const *	getIt () const

Private Attributes
BranchDescription const &	branchDescription_

cet::exempt_ptr< DelayedReader const > const	delayedReader_

std::recursive_mutex	mutex_ {}

std::atomic< ProductProvenance const * >	productProvenance_ {nullptr}

std::atomic< EDProduct * >	product_

std::atomic< RangeSet * >	rangeSet_

grouptype const	grpType_

std::atomic< EDProduct * >	partnerProduct_ {nullptr}

std::atomic< EDProduct * >	baseProduct_ {nullptr}

std::atomic< EDProduct * >	partnerBaseProduct_ {nullptr}

Detailed Description

Definition at line 30 of file Group.h.

Member Enumeration Documentation

enum art::Group::grouptype

strong

Enumerator
normal
assns
assnsWithData

Definition at line 34 of file Group.h.

34 { normal = 0, assns = 1, assnsWithData = 2 };

Constructor & Destructor Documentation

art::Group::~Group ( )

Definition at line 20 of file Group.cc.

   {
     delete productProvenance_.load();
     delete product_.load();
     delete rangeSet_.load();
     delete partnerProduct_.load();
     delete baseProduct_.load();
     delete partnerBaseProduct_.load();
   }

art::Group::Group	(	DelayedReader *	reader,
		BranchDescription const &	bd,
		std::unique_ptr< RangeSet > &&	rs,
		grouptype const	gt,
		std::unique_ptr< EDProduct > &&	edp = `nullptr`
	)

Definition at line 30 of file Group.cc.

References delayedReader_, grpType_, product_, and rangeSet_.

     : branchDescription_{bd}
     , delayedReader_{reader}
     , product_{edp.release()}
     , rangeSet_{rs.release()}
     , grpType_{gt}
   {}

Member Function Documentation

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

Definition at line 54 of file Group.cc.

References assns, baseProduct_, grpType_, mutex_, normal, partnerBaseProduct_, partnerProduct_, and product_.

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

   {
     std::lock_guard sentry{mutex_};
     if (grpType_ == grouptype::normal) {
       return product_.load();
     }
     EDProduct* result = product_.load();
     if (result == nullptr) {
       result = partnerProduct_.load();
     }
     if (grpType_ == grouptype::assns) {
       return result;
     }
     if (result != nullptr) {
       return result;
     }
     result = baseProduct_.load();
     if (result == nullptr) {
       result = partnerBaseProduct_.load();
     }
     return result;
   }

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

inherited

Definition at line 10 of file EDProductGetter.cc.

References art::EDProductGetter::getIt_().

Referenced by art::RefCore::isAvailable(), and art::ProductPtr< T >::product_().

   {
     return getIt_();
   }

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

overridevirtual

Reimplemented from art::EDProductGetter.

Definition at line 43 of file Group.cc.

References grpType_, mutex_, normal, product_, resolveProductIfAvailable(), and uniqueProduct().

   {
     std::lock_guard sentry{mutex_};
     if (grpType_ == grouptype::normal) {
       resolveProductIfAvailable();
       return product_.load();
     }
     return uniqueProduct();
   }

bool art::Group::productAvailable ( ) const

Definition at line 206 of file Group.cc.

References branchDescription_, art::BranchDescription::branchType(), delayedReader_, art::BranchDescription::dropped(), art::productstatus::dummyToPreventDoubleCount(), art::InRun, art::InSubRun, art::errors::LogicError, mutex_, art::productstatus::neverCreated(), art::productstatus::present(), art::BranchDescription::present(), art::BranchDescription::produced(), product_, art::BranchDescription::productID(), productProvenance_, and art::productstatus::uninitialized().

Referenced by resolveProductIfAvailable(), and tryToResolveProduct().

   {
     if (branchDescription_.dropped()) {
       // Not a product we are producing this time around, and it is not
       // present in any of the input files we have opened so far.
       return false;
     }
     assert(branchDescription_.present() || branchDescription_.produced());
     std::lock_guard sentry{mutex_};
     bool availableAfterCombine{false};
     if ((branchDescription_.branchType() == InSubRun) ||
         (branchDescription_.branchType() == InRun)) {
       availableAfterCombine =
         delayedReader_->isAvailableAfterCombine(branchDescription_.productID());
     }
     auto status = productstatus::uninitialized();
     if (productProvenance_.load() == nullptr) {
       // No provenance, must be a produced product which has not been
       // put yet, or a non-produced product that is available after
       // combine (agggregation) and not yet read, or a non-produced
       // product in a secondary file that has not yet been opened.
       if (!branchDescription_.produced()) {
         if (availableAfterCombine) {
           // No provenance, not produced, but we can get it from the
           // input, we just have not done so yet.  Claim the product is
           // available.
           return true;
         }
         // Not produced, not availableAfterCombine, must be in a
         // secondary file that has not yet been opened. We report it as
         // not available so that the Principal getBy* routines will try
         // the next secondary file.
         return false;
       }
       if (product_.load()) {
         throw Exception(errors::LogicError, "Group::status():")
           << "We have a produced product, the product has been put(), but "
              "there is no provenance!\n";
       }
       // We have a product product which has not been put(), and has no
       // provenance (as it should be).
       status = productstatus::neverCreated();
     } else {
       // Not a produced product, and not yet delay read, use the status
       // from the on-file provenance.
       status = productProvenance_.load()->productStatus();
     }
     if ((branchDescription_.branchType() == InSubRun) ||
         (branchDescription_.branchType() == InRun)) {
       if (!availableAfterCombine) {
         // We know this is a produced run or subrun product which is not
         // present in any fragments.
         return status == productstatus::present();
       }
     }
     // We now know we are either an event or results product, or we are
     // a run or subrun product that can become valid through product
     // combination (aggregation).
     if (status == productstatus::dummyToPreventDoubleCount()) {
       // We now know that we are a run or subrun product that can become
       // valid through product combination (aggregation).  Special case
       // this and report the product as available even though the the
       // provenance product status is a special flag that is not the
       // present status.
       // This is here to allow fetching of a product specially marked by
       // RootOutputFile as a dummy with an invalid range set created to
       // prevent double-counting when combining run/subrun products.  We
       // allow the fetch to happen because the call to
       // isPossiblyAvailable above determined that the fetch will result
       // in a valid and present product, even though this particular
       // dummy one is not.
       return true;
     }
     // Note: Technically this is not necessary since the Wrapper present
     //       flag covers this case, but this way we never do the I/O on
     //       the product if we already have the provenance.
     return status == productstatus::present();
   }

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

noexcept

Definition at line 126 of file Group.cc.

References branchDescription_.

   {
     return branchDescription_;
   }

ProductID art::Group::productID ( ) const

Definition at line 132 of file Group.cc.

References branchDescription_, and art::BranchDescription::productID().

   {
     return branchDescription_.productID();
   }

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

Definition at line 145 of file Group.cc.

References mutex_, and productProvenance_.

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

   {
     std::lock_guard sentry{mutex_};
     return productProvenance_.load();
   }

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

Definition at line 138 of file Group.cc.

References mutex_, and rangeSet_.

   {
     std::lock_guard sentry{mutex_};
     return *rangeSet_.load();
   }

void art::Group::removeCachedProduct ( )

Definition at line 178 of file Group.cc.

References assns, baseProduct_, branchDescription_, grpType_, art::RangeSet::invalid(), art::errors::LogicError, mutex_, normal, partnerBaseProduct_, partnerProduct_, art::BranchDescription::produced(), product_, and rangeSet_.

   {
     std::lock_guard sentry{mutex_};
     if (branchDescription_.produced()) {
       throw Exception(errors::LogicError, "Group::removeCachedProduct():")
         << "Attempt to remove a produced product!\n"
         << "This routine should only be used to remove large data products "
         << "read from disk (like raw digits).\n";
     }
     delete product_.load();
     product_ = nullptr;
     if (grpType_ == grouptype::normal) {
       return;
     }
     delete partnerProduct_.load();
     partnerProduct_ = nullptr;
     if (grpType_ == grouptype::assns) {
       return;
     }
     delete baseProduct_.load();
     baseProduct_ = nullptr;
     delete partnerBaseProduct_.load();
     partnerBaseProduct_ = nullptr;
     delete rangeSet_.load();
     rangeSet_ = new RangeSet{RangeSet::invalid()};
   }

bool art::Group::resolveProductIfAvailable ( TypeID wanted_wrapper = TypeID{} ) const

Definition at line 286 of file Group.cc.

References assns, assnsWithData, baseProduct_, branchDescription_, delayedReader_, grpType_, art::LeftRight, art::LeftRightData, mutex_, normal, partnerBaseProduct_, partnerProduct_, art::BranchDescription::produced(), product_, productAvailable(), art::BranchDescription::productID(), rangeSet_, art::RightLeft, art::RightLeftData, and art::TypeID::typeInfo().

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

   {
     std::lock_guard sentry{mutex_};
     // Now try to get the master product.
     if (product_.load() == nullptr) {
       // Not already resolved.
       if (branchDescription_.produced()) {
         // Never produced, hopeless.
         return false;
       }
       if (!productAvailable()) {
         // Not possible to get it, hopeless.
         return false;
       }
       // Now try to read it.
       // Note: This may call back to us to update the product
       // provenance if run or subRun data product merging creates a
       // new provenance.
       product_ =
         delayedReader_
           ->getProduct(this, branchDescription_.productID(), *rangeSet_.load())
           .release();
       if (product_.load() == nullptr) {
         // We failed to get the master product, hopeless.
         return false;
       }
     }
 
     if (!wanted_wrapper_type) {
       // The type of the product is not known, therefore the on-disk
       // representation is sufficient.
       return true;
     }
 
     if (grpType_ == grouptype::normal) {
       // If we get here, we have successfully read a normal product.
       return true;
     }
 
     assert(grpType_ != grouptype::normal);
     auto normal_metatype = (grpType_ == grouptype::assns) ?
                              product_metatype::LeftRight :
                              product_metatype::LeftRightData;
 
     auto assns_type_ids = product_.load()->getTypeIDs();
     assert(!assns_type_ids.empty());
 
     if (wanted_wrapper_type == assns_type_ids.at(normal_metatype)) {
       return true;
     }
 
     auto partner_metatype = (grpType_ == grouptype::assns) ?
                               product_metatype::RightLeft :
                               product_metatype::RightLeftData;
     if (wanted_wrapper_type == assns_type_ids.at(partner_metatype)) {
       if (partnerProduct_.load() != nullptr) {
         // They wanted the partner product, and we have already made it, done.
         return true;
       }
       // They want the partner product, ask the wrapper to make it for us,
       // who ends up asking the assns to do it.
       partnerProduct_ =
         product_.load()->makePartner(wanted_wrapper_type.typeInfo()).release();
       return partnerProduct_.load() != nullptr;
     }
 
     assert(grpType_ == grouptype::assnsWithData);
 
     if (wanted_wrapper_type == assns_type_ids.at(product_metatype::LeftRight)) {
       if (baseProduct_.load() != nullptr) {
         // They wanted the base product, and we have already made it, done.
         return true;
       }
       // They want the base, ask the wrapper to make it for us,
       // who ends up asking the assns to do it.
       baseProduct_ =
         product_.load()->makePartner(wanted_wrapper_type.typeInfo()).release();
       return baseProduct_.load() != nullptr;
     }
     if (partnerBaseProduct_.load() != nullptr) {
       // They wanted the partner base product, and we have already made it,
       // done.
       return true;
     }
     partnerBaseProduct_ =
       product_.load()->makePartner(wanted_wrapper_type.typeInfo()).release();
     return partnerBaseProduct_.load() != nullptr;
   }

void art::Group::setProductAndProvenance	(	std::unique_ptr< ProductProvenance const > &&	pp,
		std::unique_ptr< EDProduct > &&	edp,
		std::unique_ptr< RangeSet > &&	rs
	)

Definition at line 164 of file Group.cc.

References mutex_, product_, productProvenance_, and rangeSet_.

   {
     std::lock_guard sentry{mutex_};
     delete productProvenance_.load();
     productProvenance_ = pp.release();
     delete product_.load();
     product_ = edp.release();
     delete rangeSet_.load();
     rangeSet_ = rs.release();
   }

void art::Group::setProductProvenance ( std::unique_ptr< ProductProvenance const > && pp )

Definition at line 155 of file Group.cc.

References mutex_, and productProvenance_.

   {
     std::lock_guard sentry{mutex_};
     delete productProvenance_.load();
     productProvenance_ = pp.release();
   }

bool art::Group::tryToResolveProduct ( TypeID const & wanted_wrapper )

Definition at line 377 of file Group.cc.

References mutex_, productAvailable(), and resolveProductIfAvailable().

   {
     std::lock_guard sentry{mutex_};
     resolveProductIfAvailable(wanted_wrapper);
 
     // If the product is a dummy filler, it will now be marked unavailable.
     return productAvailable();
   }

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

Definition at line 78 of file Group.cc.

References grpType_, art::errors::LogicError, mutex_, normal, and product_.

Referenced by getIt_().

   {
     std::lock_guard sentry{mutex_};
     if (grpType_ == grouptype::normal) {
       return product_.load();
     }
     throw Exception(errors::LogicError, "AmbiguousProduct")
       << cet::demangle_symbol(typeid(*this).name())
       << " was asked for a held product (uniqueProduct()) "
       << "without specifying which one was wanted.\n";
   }

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

Definition at line 91 of file Group.cc.

References assns, baseProduct_, grpType_, art::LeftRight, mutex_, normal, partnerBaseProduct_, partnerProduct_, product_, art::RightLeft, and art::RightLeftData.

   {
     std::lock_guard sentry{mutex_};
     if (product_.load() == nullptr) {
       return nullptr;
     }
     if (grpType_ == grouptype::normal) {
       return product_.load();
     }
 
     auto assns_type_ids = product_.load()->getTypeIDs();
     if (grpType_ == grouptype::assns) {
       assert(assns_type_ids.size() == 2ull);
       if (wanted_wrapper_type ==
           assns_type_ids.at(product_metatype::RightLeft)) {
         return partnerProduct_.load();
       }
       return product_.load();
     }
 
     assert(assns_type_ids.size() == 4ull);
     if (wanted_wrapper_type == assns_type_ids.at(product_metatype::RightLeft)) {
       return partnerBaseProduct_.load();
     }
     if (wanted_wrapper_type == assns_type_ids.at(product_metatype::LeftRight)) {
       return baseProduct_.load();
     }
     if (wanted_wrapper_type ==
         assns_type_ids.at(product_metatype::RightLeftData)) {
       return partnerProduct_.load();
     }
     return product_.load();
   }