art::Group Class Reference

#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 > &&)
Public Member Functions inherited from art::EDProductGetter
virtual	~EDProductGetter ()
	EDProductGetter ()
	EDProductGetter (EDProductGetter const &)=delete
	EDProductGetter (EDProductGetter &&)=delete
EDProductGetter &	operator= (EDProductGetter const &)=delete
EDProductGetter &	operator= (EDProductGetter &&)=delete
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.

{ 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.

    : 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.

  {
    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::Group::getIt_ ( ) const

overridevirtual

Reimplemented from art::EDProductGetter.

Definition at line 43 of file Group.cc.

  {
    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.

  {
    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.

  {
    return branchDescription_;
  }

ProductID art::Group::productID

(

)

const

Definition at line 132 of file Group.cc.

  {
    return branchDescription_.productID();
  }

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

(

)

const

Definition at line 145 of file Group.cc.

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

RangeSet const & art::Group::rangeOfValidity

(

)

const

Definition at line 138 of file Group.cc.

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

void art::Group::removeCachedProduct

(

)

Definition at line 178 of file Group.cc.

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

bool art::Group::resolveProductIfAvailable

(

TypeID

wanted_wrapper = TypeID{}

)

const

Definition at line 286 of file Group.cc.

  {
    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.

  {
    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.

  {
    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.

  {
    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.

  {
    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.

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

Member Data Documentation

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

mutableprivate

Definition at line 116 of file Group.h.

BranchDescription const& art::Group::branchDescription_

private

Definition at line 74 of file Group.h.

cet::exempt_ptr<DelayedReader const> const art::Group::delayedReader_

private

Definition at line 78 of file Group.h.

grouptype const art::Group::grpType_

private

Definition at line 102 of file Group.h.

std::recursive_mutex art::Group::mutex_ {}

mutableprivate

Definition at line 87 of file Group.h.

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

mutableprivate

Definition at line 120 of file Group.h.

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

mutableprivate

Definition at line 109 of file Group.h.

std::atomic<EDProduct*> art::Group::product_

mutableprivate

Definition at line 96 of file Group.h.

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

private

Definition at line 91 of file Group.h.

std::atomic<RangeSet*> art::Group::rangeSet_

mutableprivate

Definition at line 100 of file Group.h.

---

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

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