#include <DataViewImpl.h>

Inheritance diagram for art::DataViewImpl:

Classes
struct	PMValue

Public Member Functions
	~DataViewImpl ()

	DataViewImpl (BranchType bt, Principal const &p, ModuleContext const &mc, bool recordParents, RangeSet const &rs=RangeSet::invalid())

	DataViewImpl (DataViewImpl const &)=delete

	DataViewImpl (DataViewImpl &&)=delete

DataViewImpl &	operator= (DataViewImpl const &)=delete

DataViewImpl &	operator= (DataViewImpl &)=delete

RunID	runID () const

SubRunID	subRunID () const

EventID	eventID () const

RunNumber_t	run () const

SubRunNumber_t	subRun () const

EventNumber_t	event () const

Timestamp const &	beginTime () const

Timestamp const &	endTime () const

Timestamp	time () const

bool	isRealData () const

EventAuxiliary::ExperimentType	experimentType () const

History const &	history () const

ProcessHistoryID const &	processHistoryID () const

ProcessHistory const &	processHistory () const

template<typename PROD >
bool	removeCachedProduct (Handle< PROD > &) const

EDProductGetter const *	productGetter (ProductID const pid) const

bool	getProcessParameterSet (std::string const &process, fhicl::ParameterSet &) const

template<typename PROD >
PROD const &	getProduct (InputTag const &tag) const

template<typename PROD >
PROD const &	getProduct (ProductToken< PROD > const &token) const

template<typename PROD >
Handle< PROD >	getHandle (SelectorBase const &) const

template<typename PROD >
Handle< PROD >	getHandle (ProductID const pid) const

template<typename PROD >
Handle< PROD >	getHandle (InputTag const &tag) const

template<typename PROD >
Handle< PROD >	getHandle (ProductToken< PROD > const &token) const

template<typename PROD >
ValidHandle< PROD >	getValidHandle (InputTag const &tag) const

template<typename PROD >
ValidHandle< PROD >	getValidHandle (ProductToken< PROD > const &token) const

template<typename PROD >
std::vector< InputTag >	getInputTags (SelectorBase const &selector=MatchAllSelector{}) const

template<typename PROD >
std::vector< ProductToken< PROD > >	getProductTokens (SelectorBase const &selector=MatchAllSelector{}) const

template<typename PROD >
std::vector< Handle< PROD > >	getMany (SelectorBase const &selector=MatchAllSelector{}) const

template<typename PROD >
bool	get (SelectorBase const &, Handle< PROD > &result) const

template<typename PROD >
bool	get (ProductID const pid, Handle< PROD > &result) const

template<typename PROD >
bool	getByLabel (std::string const &label, std::string const &instance, Handle< PROD > &result) const

template<typename PROD >
bool	getByLabel (std::string const &label, std::string const &instance, std::string const &process, Handle< PROD > &result) const

template<typename PROD >
bool	getByLabel (InputTag const &tag, Handle< PROD > &result) const

template<typename PROD >
bool	getByToken (ProductToken< PROD > const &token, Handle< PROD > &result) const

template<typename PROD >
PROD const *	getPointerByLabel (InputTag const &tag) const

template<typename PROD >
void	getMany (SelectorBase const &, std::vector< Handle< PROD >> &results) const

template<typename PROD >
void	getManyByType (std::vector< Handle< PROD >> &results) const

template<typename ELEMENT >
std::size_t	getView (std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName, std::vector< ELEMENT const * > &result) const

template<typename ELEMENT >
std::size_t	getView (std::string const &moduleLabel, std::string const &productInstanceName, std::vector< ELEMENT const * > &result) const

template<typename ELEMENT >
std::size_t	getView (InputTag const &, std::vector< ELEMENT const * > &result) const

template<typename ELEMENT >
std::size_t	getView (ViewToken< ELEMENT > const &, std::vector< ELEMENT const * > &result) const

template<typename ELEMENT >
bool	getView (std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName, View< ELEMENT > &result) const

template<typename ELEMENT >
bool	getView (std::string const &moduleLabel, std::string const &productInstanceName, View< ELEMENT > &result) const

template<typename ELEMENT >
bool	getView (InputTag const &, View< ELEMENT > &result) const

template<typename ELEMENT >
bool	getView (ViewToken< ELEMENT > const &, View< ELEMENT > &result) const

template<typename T >
ProductID	getProductID (std::string const &instance_name="") const

cet::exempt_ptr< BranchDescription const >	getProductDescription (ProductID) const

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance={})

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, RangeSet const &rs)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, FullSemantic< Level::Run > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, FragmentSemantic< Level::Run > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, RangedFragmentSemantic< Level::Run > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, FullSemantic< Level::Run >)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, FragmentSemantic< Level::Run >)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, RangedFragmentSemantic< Level::Run > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, FullSemantic< Level::SubRun > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, FragmentSemantic< Level::SubRun > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, RangedFragmentSemantic< Level::SubRun > semantic)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, FullSemantic< Level::SubRun >)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, FragmentSemantic< Level::SubRun >)

template<typename PROD >
ProductID	put (std::unique_ptr< PROD > &&edp, std::string const &instance, RangedFragmentSemantic< Level::SubRun > semantic)

void	movePutProductsToPrincipal (Principal &principal)

void	movePutProductsToPrincipal (Principal &principal, bool const checkProducts, std::map< TypeLabel, BranchDescription > const *expectedProducts)

Private Member Functions
std::string const &	getProcessName_ (std::string const &) const

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

void	recordAsParent_ (cet::exempt_ptr< Group const > grp) const

cet::exempt_ptr< Group const >	getContainerForView_ (TypeID const &, std::string const &moduleLabel, std::string const &productInstanceName, ProcessTag const &processTag) const

Private Attributes
std::recursive_mutex	mutex_ {}

BranchType const	branchType_

Principal const &	principal_

ModuleContext const &	mc_

ModuleDescription const &	md_

bool const	recordParents_

RangeSet	rangeSet_ {RangeSet::invalid()}

std::set< ProductID >	retrievedProducts_ {}

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

Friends
class	detail::Analyzer

class	detail::Filter

class	detail::Producer

class	ResultsProducer

class	ProducingService

Detailed Description

Definition at line 64 of file DataViewImpl.h.

Constructor & Destructor Documentation

art::DataViewImpl::~DataViewImpl ( )

default

art::DataViewImpl::DataViewImpl	(	BranchType	bt,
		Principal const &	p,
		ModuleContext const &	mc,
		bool	recordParents,
		RangeSet const &	rs = `RangeSet::invalid()`
	)

explicit

Definition at line 36 of file DataViewImpl.cc.

     : branchType_{bt}
     , principal_{principal}
     , mc_{mc}
     , md_{mc.moduleDescription()}
     , recordParents_{recordParents}
     , rangeSet_{rs}
   {}

art::DataViewImpl::DataViewImpl ( DataViewImpl const & )

delete

art::DataViewImpl::DataViewImpl ( DataViewImpl && )

delete

Member Function Documentation

Timestamp const & art::DataViewImpl::beginTime ( ) const

Definition at line 92 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.beginTime();
   }

Timestamp const & art::DataViewImpl::endTime ( ) const

Definition at line 99 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.endTime();
   }

EventNumber_t art::DataViewImpl::event ( ) const

Definition at line 85 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.event();
   }

EventID art::DataViewImpl::eventID ( ) const

Definition at line 64 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.eventID();
   }

EventAuxiliary::ExperimentType art::DataViewImpl::experimentType ( ) const

Definition at line 120 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.ExperimentType();
   }

template<typename PROD >

bool art::DataViewImpl::get	(	SelectorBase const &	sel,
		Handle< PROD > &	result
	)		const

Definition at line 606 of file DataViewImpl.h.

   {
     result = getHandle<PROD>(sel);
     return static_cast<bool>(result);
   }

template<typename PROD >

bool art::DataViewImpl::get	(	ProductID const	pid,
		Handle< PROD > &	result
	)		const

Definition at line 614 of file DataViewImpl.h.

   {
     result = getHandle<PROD>(pid);
     return static_cast<bool>(result);
   }

template<typename PROD >

bool art::DataViewImpl::getByLabel	(	std::string const &	label,
		std::string const &	instance,
		Handle< PROD > &	result
	)		const

Definition at line 633 of file DataViewImpl.h.

   {
     result = getHandle<PROD>({moduleLabel, instance});
     return static_cast<bool>(result);
   }

template<typename PROD >

bool art::DataViewImpl::getByLabel	(	std::string const &	label,
		std::string const &	instance,
		std::string const &	process,
		Handle< PROD > &	result
	)		const

Definition at line 622 of file DataViewImpl.h.

   {
     result = getHandle<PROD>({moduleLabel, productInstanceName, processName});
     return static_cast<bool>(result);
   }

template<typename PROD >

bool art::DataViewImpl::getByLabel	(	InputTag const &	tag,
		Handle< PROD > &	result
	)		const

Definition at line 643 of file DataViewImpl.h.

   {
     result = getHandle<PROD>(tag);
     return static_cast<bool>(result);
   }

template<typename PROD >

bool art::DataViewImpl::getByToken	(	ProductToken< PROD > const &	token,
		Handle< PROD > &	result
	)		const

Definition at line 660 of file DataViewImpl.h.

   {
     result = getHandle(token);
     return static_cast<bool>(result);
   }

exempt_ptr< Group const > art::DataViewImpl::getContainerForView_	(	TypeID const &	typeID,
		std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		ProcessTag const &	processTag
	)		const

private

Definition at line 314 of file DataViewImpl.cc.

   {
     // Check that the consumesView<ELEMENT, BT>(InputTag),
     // or the mayConsumeView<ELEMENT, BT>(InputTag)
     // is actually present.
     ConsumesInfo::instance()->validateConsumedProduct(
       branchType_,
       md_,
       ProductInfo{ProductInfo::ConsumableType::ViewElement,
                   typeID,
                   moduleLabel,
                   productInstanceName,
                   processTag});
     // Fetch the specified data products, which must be containers.
     auto const groups = principal_.getMatchingSequence(
       mc_,
       Selector{ModuleLabelSelector{moduleLabel} &&
                ProductInstanceNameSelector{productInstanceName} &&
                ProcessNameSelector{processTag.name()}},
       processTag);
     auto qrs = resolve_products(groups, TypeID{});
     // Remove any containers that do not allow upcasting of their
     // elements to the desired element type.
     auto new_end =
       remove_if(qrs.begin(), qrs.end(), [&typeID](auto const& gqr) {
         auto const group = gqr.result();
         assert(group->productDescription().supportsView());
         return !detail::upcastAllowed(*group->uniqueProduct()->typeInfo(),
                                       typeID.typeInfo());
       });
     qrs.erase(new_end, qrs.end());
     // Throw if there is not one and only one container to return.
     if (qrs.size() != 1) {
       Exception e{errors::ProductNotFound};
       e << "getView: Found "
         << (qrs.empty() ? "no products" : "more than one product")
         << " matching all criteria\n"
         << "Looking for sequence of type: " << typeID << "\n"
         << "Looking for module label: " << moduleLabel << "\n"
         << "Looking for productInstanceName: " << productInstanceName << "\n";
       if (!processTag.name().empty()) {
         e << "Looking for processName: " << processTag.name() << "\n";
       }
       throw e;
     }
     // And return the single result.
     return qrs[0].result();
   }

template<typename PROD >

Handle< PROD > art::DataViewImpl::getHandle ( SelectorBase const & sel ) const

Definition at line 382 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     // We do *not* track whether consumes was called for a SelectorBase.
     ProcessTag const processTag{"", md_.processName()};
     auto qr = principal_.getBySelector(
       mc_, WrappedTypeID::make<PROD>(), sel, processTag);
     bool const ok = qr.succeeded() && !qr.failed();
     if (recordParents_ && ok) {
       recordAsParent_(qr.result());
     }
     return Handle<PROD>{qr};
   }

template<typename PROD >

Handle< PROD > art::DataViewImpl::getHandle ( ProductID const pid ) const

Definition at line 398 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     auto qr = principal_.getByProductID(pid);
     bool const ok = qr.succeeded() && !qr.failed();
     if (recordParents_ && ok) {
       recordAsParent_(qr.result());
     }
     return Handle<PROD>{qr};
   }

template<typename PROD >

Handle< PROD > art::DataViewImpl::getHandle ( InputTag const & tag ) const

Definition at line 411 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     auto const wrapped = WrappedTypeID::make<PROD>();
     ProcessTag const processTag{tag.process(), md_.processName()};
     ProductInfo const pinfo{ProductInfo::ConsumableType::Product,
                             wrapped.product_type,
                             tag.label(),
                             tag.instance(),
                             processTag};
     ConsumesInfo::instance()->validateConsumedProduct(branchType_, md_, pinfo);
     GroupQueryResult qr = principal_.getByLabel(
       mc_, wrapped, tag.label(), tag.instance(), processTag);
     bool const ok = qr.succeeded() && !qr.failed();
     if (recordParents_ && ok) {
       recordAsParent_(qr.result());
     }
     return Handle<PROD>{qr};
   }

template<typename PROD >

Handle< PROD > art::DataViewImpl::getHandle ( ProductToken< PROD > const & token ) const

Definition at line 433 of file DataViewImpl.h.

   {
     return getHandle<PROD>(token.inputTag_);
   }

template<typename PROD >

std::vector< InputTag > art::DataViewImpl::getInputTags ( SelectorBase const & selector = MatchAllSelector{} ) const

Definition at line 457 of file DataViewImpl.h.

   {
     auto const wrapped = WrappedTypeID::make<PROD>();
     ProcessTag const processTag{"", md_.processName()};
     return principal_.getInputTags(mc_, wrapped, selector, processTag);
   }

template<typename PROD >

std::vector< Handle< PROD > > art::DataViewImpl::getMany ( SelectorBase const & selector = MatchAllSelector{} ) const

Definition at line 479 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     auto const wrapped = WrappedTypeID::make<PROD>();
     ConsumesInfo::instance()->validateConsumedProduct(
       branchType_,
       md_,
       ProductInfo{ProductInfo::ConsumableType::Many, wrapped.product_type});
     ProcessTag const processTag{"", md_.processName()};
     std::vector<Handle<PROD>> products;
     for (auto const& qr : principal_.getMany(mc_, wrapped, sel, processTag)) {
       products.emplace_back(qr);
       if (recordParents_) {
         recordAsParent_(qr.result());
       }
     }
     return products;
   }

template<typename PROD >

void art::DataViewImpl::getMany	(	SelectorBase const &	sel,
		std::vector< Handle< PROD >> &	results
	)		const

Definition at line 669 of file DataViewImpl.h.

   {
     results = getMany<PROD>(sel);
   }

template<typename PROD >

void art::DataViewImpl::getManyByType ( std::vector< Handle< PROD >> & results ) const

Definition at line 677 of file DataViewImpl.h.

   {
     results = getMany<PROD>();
   }

template<typename PROD >

PROD const * art::DataViewImpl::getPointerByLabel ( InputTag const & tag ) const

Definition at line 651 of file DataViewImpl.h.

   {
     Handle<PROD> h;
     getByLabel(tag, h);
     return h.product();
   }

string const & art::DataViewImpl::getProcessName_ ( std::string const & specifiedProcessName ) const

private

Definition at line 259 of file DataViewImpl.cc.

   {
     return specifiedProcessName == "current_process"s ? md_.processName() :
                                                         specifiedProcessName;
   }

bool art::DataViewImpl::getProcessParameterSet	(	std::string const &	process,
		fhicl::ParameterSet &	ps
	)		const

Definition at line 155 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     if (branchType_ != InEvent) {
       return false;
     }
     ProcessHistory ph;
     if (!ProcessHistoryRegistry::get(principal_.history().processHistoryID(),
                                      ph)) {
       throw Exception(errors::NotFound)
         << "ProcessHistoryID " << principal_.history().processHistoryID()
         << " is not found in the ProcessHistoryRegistry.\n"
         << "This file is malformed.\n";
     }
     auto const config = ph.getConfigurationForProcess(processName);
     if (config) {
       fhicl::ParameterSetRegistry::get(config->parameterSetID(), ps);
     }
     return config.has_value();
   }

template<typename PROD >

PROD const & art::DataViewImpl::getProduct ( InputTag const & tag ) const

Definition at line 367 of file DataViewImpl.h.

   {
     return *getValidHandle<PROD>(tag);
   }

template<typename PROD >

PROD const & art::DataViewImpl::getProduct ( ProductToken< PROD > const & token ) const

Definition at line 374 of file DataViewImpl.h.

   {
     return *getValidHandle(token);
   }

cet::exempt_ptr< BranchDescription const > art::DataViewImpl::getProductDescription ( ProductID pid ) const

Definition at line 178 of file DataViewImpl.cc.

   {
     return principal_.getProductDescription(pid);
   }

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

private

Definition at line 266 of file DataViewImpl.cc.

   {
     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,
                       "DataViewImpl::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
     // DataViewImpl object.  It is therefore safe to dereference.
     return *bd;
   }

template<typename PROD >

ProductID art::DataViewImpl::getProductID ( std::string const & instance_name = "" ) const

Definition at line 338 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     TypeID const type{typeid(PROD)};
     auto const& product_name = canonicalProductName(
       type.friendlyClassName(), md_.moduleLabel(), instance, md_.processName());
     ProductID const pid{product_name};
     auto desc = principal_.getProductDescription(pid);
     if (!desc) {
       throw art::Exception(art::errors::ProductRegistrationFailure,
                            "DataViewImpl::getProductID: 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 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
     // DataViewImpl object.  It is therefore safe to dereference.
     return desc->productID();
   }

template<typename PROD >

std::vector< ProductToken< PROD > > art::DataViewImpl::getProductTokens ( SelectorBase const & selector = MatchAllSelector{} ) const

Definition at line 466 of file DataViewImpl.h.

   {
     auto const tags = getInputTags<PROD>(selector);
     std::vector<ProductToken<PROD>> tokens;
     tokens.reserve(tags.size());
     cet::transform_all(tags, back_inserter(tokens), [](auto const& tag) {
       return ProductToken<PROD>{tag};
     });
     return tokens;
   }

template<typename PROD >

ValidHandle< PROD > art::DataViewImpl::getValidHandle ( InputTag const & tag ) const

Definition at line 441 of file DataViewImpl.h.

   {
     Handle<PROD> h;
     getByLabel(tag, h);
     return ValidHandle{h.product(), *h.provenance()};
   }

template<typename PROD >

ValidHandle< PROD > art::DataViewImpl::getValidHandle ( ProductToken< PROD > const & token ) const

Definition at line 450 of file DataViewImpl.h.

   {
     return getValidHandle<PROD>(token.inputTag_);
   }

template<typename ELEMENT >

std::size_t art::DataViewImpl::getView	(	std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		std::string const &	processName,
		std::vector< ELEMENT const * > &	result
	)		const

Definition at line 500 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     std::size_t const orig_size = result.size();
     auto grp = getContainerForView_(TypeID{typeid(ELEMENT)},
                                     moduleLabel,
                                     productInstanceName,
                                     ProcessTag{processName, md_.processName()});
     if (recordParents_) {
       recordAsParent_(grp);
     }
     auto const view = grp->uniqueProduct()->getView();
     std::vector<ELEMENT const*> castedView;
     for (auto p : view) {
       castedView.push_back(static_cast<ELEMENT const*>(p));
     }
     result = std::move(castedView);
     return result.size() - orig_size;
   }

template<typename ELEMENT >

std::size_t art::DataViewImpl::getView	(	std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		std::vector< ELEMENT const * > &	result
	)		const

Definition at line 525 of file DataViewImpl.h.

   {
     return getView(moduleLabel, productInstanceName, {}, result);
   }

template<typename ELEMENT >

std::size_t art::DataViewImpl::getView	(	InputTag const &	tag,
		std::vector< ELEMENT const * > &	result
	)		const

Definition at line 534 of file DataViewImpl.h.

   {
     return getView(tag.label(), tag.instance(), tag.process(), result);
   }

template<typename ELEMENT >

std::size_t art::DataViewImpl::getView	(	ViewToken< ELEMENT > const &	token,
		std::vector< ELEMENT const * > &	result
	)		const

Definition at line 542 of file DataViewImpl.h.

   {
     return getView(token.inputTag_.label(),
                    token.inputTag_.instance(),
                    token.inputTag_.process(),
                    result);
   }

template<typename ELEMENT >

bool art::DataViewImpl::getView	(	std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		std::string const &	processName,
		View< ELEMENT > &	result
	)		const

Definition at line 553 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     auto grp = getContainerForView_(TypeID{typeid(ELEMENT)},
                                     moduleLabel,
                                     productInstanceName,
                                     ProcessTag{processName, md_.processName()});
     if (recordParents_) {
       recordAsParent_(grp);
     }
     auto const view = grp->uniqueProduct()->getView();
     std::vector<ELEMENT const*> castedView;
     for (auto p : view) {
       castedView.push_back(static_cast<ELEMENT const*>(p));
     }
     result = View{move(castedView), grp->productID(), grp->uniqueProduct()};
     return true;
   }

template<typename ELEMENT >

bool art::DataViewImpl::getView	(	std::string const &	moduleLabel,
		std::string const &	productInstanceName,
		View< ELEMENT > &	result
	)		const

Definition at line 577 of file DataViewImpl.h.

   {
     return getView(moduleLabel, productInstanceName, {}, result);
   }

template<typename ELEMENT >

bool art::DataViewImpl::getView	(	InputTag const &	tag,
		View< ELEMENT > &	result
	)		const

Definition at line 586 of file DataViewImpl.h.

   {
     return getView(tag.label(), tag.instance(), tag.process(), result);
   }

template<typename ELEMENT >

bool art::DataViewImpl::getView	(	ViewToken< ELEMENT > const &	token,
		View< ELEMENT > &	result
	)		const

Definition at line 593 of file DataViewImpl.h.

   {
     return getView(token.inputTag_.label(),
                    token.inputTag_.instance(),
                    token.inputTag_.process(),
                    result);
   }

History const & art::DataViewImpl::history ( ) const

Definition at line 127 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.history();
   }

bool art::DataViewImpl::isRealData ( ) const

Definition at line 113 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.isReal();
   }

void art::DataViewImpl::movePutProductsToPrincipal ( Principal & principal )

Definition at line 237 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     for (auto& type_label_and_pmvalue : putProducts_) {
       auto& pmvalue = type_label_and_pmvalue.second;
       unique_ptr<ProductProvenance const> pp =
         make_unique<ProductProvenance const>(pmvalue.bd_.productID(),
                                              productstatus::present());
       if ((branchType_ == InRun) || (branchType_ == InSubRun)) {
         principal.put(pmvalue.bd_,
                       move(pp),
                       move(pmvalue.prod_),
                       make_unique<RangeSet>(pmvalue.rs_));
       } else {
         principal.put(
           pmvalue.bd_, move(pp), move(pmvalue.prod_), make_unique<RangeSet>());
       }
     };
     putProducts_.clear();
   }

void art::DataViewImpl::movePutProductsToPrincipal	(	Principal &	principal,
		bool const	checkProducts,
		std::map< TypeLabel, BranchDescription > const *	expectedProducts
	)

Definition at line 184 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     if (checkProducts) {
       vector<string> missing;
       for (auto const& typeLabel_and_bd : *expectedProducts) {
         if (putProducts_.find(typeLabel_and_bd.first) != putProducts_.cend()) {
           continue;
         }
         ostringstream desc;
         desc << typeLabel_and_bd.second;
         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, "DataViewImpl::checkPutProducts"}
           << errmsg.str();
       }
     }
     for (auto& type_label_and_pmvalue : putProducts_) {
       auto& pmvalue = type_label_and_pmvalue.second;
       unique_ptr<ProductProvenance const> pp;
       if (branchType_ == InEvent) {
         vector<ProductID> gotPIDs;
         if (!retrievedProducts_.empty()) {
           gotPIDs.reserve(retrievedProducts_.size());
           gotPIDs.assign(retrievedProducts_.begin(), retrievedProducts_.end());
         }
         pp = make_unique<ProductProvenance const>(
           pmvalue.bd_.productID(), productstatus::present(), gotPIDs);
       } else {
         pp = make_unique<ProductProvenance const>(pmvalue.bd_.productID(),
                                                   productstatus::present());
       }
       auto rs = detail::range_sets_supported(branchType_) ?
                   make_unique<RangeSet>(pmvalue.rs_) :
                   make_unique<RangeSet>();
       principal.put(pmvalue.bd_, move(pp), move(pmvalue.prod_), move(rs));
     };
     putProducts_.clear();
   }

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

delete

DataViewImpl& art::DataViewImpl::operator= ( DataViewImpl & )

delete

ProcessHistory const & art::DataViewImpl::processHistory ( ) const

Definition at line 141 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.processHistory();
   }

ProcessHistoryID const & art::DataViewImpl::processHistoryID ( ) const

Definition at line 134 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.history().processHistoryID();
   }

EDProductGetter const * art::DataViewImpl::productGetter ( ProductID const pid ) const

Definition at line 148 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.productGetter(pid);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance = `{}`
	)

Definition at line 686 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     TypeID const tid{typeid(PROD)};
     if (edp.get() == nullptr) {
       throw art::Exception(errors::NullPointerError)
         << "Event::put: A null unique_ptr was passed to 'put'.\n"
         << "The pointer is of type " << tid << ".\n"
         << "The specified productInstanceName was '" << instance << "'.\n";
     }
     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>>(move(edp));
     auto const& rs = detail::range_sets_supported(branchType_) ?
                        rangeSet_.collapse() :
                        RangeSet::invalid();
     bool const result =
       putProducts_.try_emplace(typeLabel, PMValue{std::move(wp), bd, rs})
         .second;
     if (!result) {
       cet::HorizontalRule rule{30};
       throw art::Exception(errors::ProductPutFailure)
         << "Event::put: Attempt to put multiple products with the\n"
         << "            following description onto the Event.\n"
         << "            Products must be unique per Event.\n"
         << rule('=') << '\n'
         << bd << rule('=') << '\n';
     }
     return bd.productID();
   }

template<typename PROD >

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

Definition at line 889 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     TypeID const tid{typeid(PROD)};
     if (edp.get() == nullptr) {
       throw art::Exception(errors::NullPointerError)
         << "Event::put: A null unique_ptr was passed to 'put'.\n"
         << "The pointer is of type " << tid << ".\n"
         << "The specified productInstanceName was '" << instance << "'.\n";
     }
     if (!rs.is_valid()) {
       throw art::Exception{errors::ProductPutFailure, "SubRun::put"}
         << "\nCannot put a product with an invalid RangeSet.\n"
         << "Please contact artists@fnal.gov.\n";
     }
     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>>(move(edp));
     auto result =
       putProducts_.try_emplace(typeLabel, PMValue{move(wp), bd, rs}).second;
     if (!result) {
       constexpr cet::HorizontalRule rule{30};
       throw art::Exception(errors::ProductPutFailure)
         << "Event::put: Attempt to put multiple products with the\n"
         << "            following description onto the Event.\n"
         << "            Products must be unique per Event.\n"
         << rule('=') << '\n'
         << bd << rule('=') << '\n';
     }
     return bd.productID();
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		FullSemantic< Level::Run >	semantic
	)

Definition at line 721 of file DataViewImpl.h.

   {
     return put(move(edp), "", semantic);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		FragmentSemantic< Level::Run >	semantic
	)

Definition at line 729 of file DataViewImpl.h.

   {
     return put(move(edp), "", semantic);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		RangedFragmentSemantic< Level::Run >	semantic
	)

Definition at line 737 of file DataViewImpl.h.

   {
     return put(move(edp), "", std::move(semantic));
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		FullSemantic< Level::Run >
	)

Definition at line 745 of file DataViewImpl.h.

   {
     return put(move(edp), instance, RangeSet::forRun(runID()));
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		FragmentSemantic< Level::Run >
	)

Definition at line 754 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     static_assert(
       detail::CanBeAggregated<PROD>::value,
       "\n\n"
       "art error: A Run product put with the semantic 'RunFragment'\n"
       "           must be able to be aggregated. Please add the appropriate\n"
       "              void aggregate(T const&)\n"
       "           function to your class, or contact artists@fnal.gov.\n");
     if (rangeSet_.collapse().is_full_run()) {
       throw art::Exception{errors::ProductPutFailure, "Run::put"}
         << "\nCannot put a product corresponding to a full Run using\n"
         << "art::runFragment().  This can happen if you attempted to\n"
         << "put a product at beginRun using art::runFragment().\n"
         << "Please use either:\n"
         << "   art::fullRun(), or\n"
         << "   art::runFragment(art::RangeSet const&)\n"
         << "or contact artists@fnal.gov for assistance.\n";
     }
     return put(move(edp), instance, rangeSet_);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		RangedFragmentSemantic< Level::Run >	semantic
	)

Definition at line 781 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     static_assert(
       detail::CanBeAggregated<PROD>::value,
       "\n\n"
       "art error: A Run product put with the semantic 'RunFragment'\n"
       "           must be able to be aggregated. Please add the appropriate\n"
       "              void aggregate(T const&)\n"
       "           function to your class, or contact artists@fnal.gov.\n");
     if (semantic.rs.collapse().is_full_run()) {
       throw art::Exception{errors::ProductPutFailure, "Run::put"}
         << "\nCannot put a product corresponding to a full Run using\n"
         << "art::runFragment(art::RangeSet&).  Please use:\n"
         << "   art::fullRun()\n"
         << "or contact artists@fnal.gov for assistance.\n";
     }
     return put(move(edp), instance, semantic.rs);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		FullSemantic< Level::SubRun >	semantic
	)

Definition at line 805 of file DataViewImpl.h.

   {
     return put(move(edp), "", semantic);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		FragmentSemantic< Level::SubRun >	semantic
	)

Definition at line 813 of file DataViewImpl.h.

   {
     return put(move(edp), "", semantic);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		RangedFragmentSemantic< Level::SubRun >	semantic
	)

Definition at line 821 of file DataViewImpl.h.

   {
     return put(move(edp), "", std::move(semantic));
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		FullSemantic< Level::SubRun >
	)

Definition at line 829 of file DataViewImpl.h.

   {
     return put(move(edp), instance, RangeSet::forSubRun(subRunID()));
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		FragmentSemantic< Level::SubRun >
	)

Definition at line 838 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     static_assert(
       detail::CanBeAggregated<PROD>::value,
       "\n\n"
       "art error: A SubRun product put with the semantic 'SubRunFragment'\n"
       "           must be able to be aggregated. Please add the appropriate\n"
       "              void aggregate(T const&)\n"
       "           function to your class, or contact artists@fnal.gov.\n");
     if (rangeSet_.collapse().is_full_subRun()) {
       throw art::Exception(errors::ProductPutFailure, "SubRun::put")
         << "\nCannot put a product corresponding to a full SubRun using\n"
         << "art::subRunFragment().  This can happen if you attempted to\n"
         << "put a product at beginSubRun using art::subRunFragment().\n"
         << "Please use either:\n"
         << "   art::fullSubRun(), or\n"
         << "   art::subRunFragment(art::RangeSet const&)\n"
         << "or contact artists@fnal.gov for assistance.\n";
     }
     return put(move(edp), instance, rangeSet_);
   }

template<typename PROD >

ProductID art::DataViewImpl::put	(	std::unique_ptr< PROD > &&	edp,
		std::string const &	instance,
		RangedFragmentSemantic< Level::SubRun >	semantic
	)

Definition at line 865 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     static_assert(
       detail::CanBeAggregated<PROD>::value,
       "\n\n"
       "art error: A SubRun product put with the semantic 'SubRunFragment'\n"
       "           must be able to be aggregated. Please add the appropriate\n"
       "              void aggregate(T const&)\n"
       "           function to your class, or contact artists@fnal.gov.\n");
     if (semantic.rs.collapse().is_full_subRun()) {
       throw art::Exception{errors::ProductPutFailure, "Run::put"}
         << "\nCannot put a product corresponding to a full SubRun using\n"
         << "art::subRunFragment(art::RangeSet&).  Please use:\n"
         << "   art::fullSubRun()\n"
         << "or contact artists@fnal.gov for assistance.\n";
     }
     return put(move(edp), instance, semantic.rs);
   }

void art::DataViewImpl::recordAsParent_ ( cet::exempt_ptr< Group const > grp ) const

private

Definition at line 301 of file DataViewImpl.cc.

   {
     if (grp->productDescription().transient()) {
       // If the product retrieved is transient, don't use its
       // ProductID; use the ProductID's of its parents.
       auto const& parents = grp->productProvenance()->parentage().parents();
       retrievedProducts_.insert(cbegin(parents), cend(parents));
     } else {
       retrievedProducts_.insert(grp->productDescription().productID());
     }
   }

template<typename PROD >

bool art::DataViewImpl::removeCachedProduct ( Handle< PROD > & h ) const

Definition at line 927 of file DataViewImpl.h.

   {
     std::lock_guard lock{mutex_};
     bool result{false};
     if (h.isValid() && !h.provenance()->produced()) {
       principal_.removeCachedProduct(h.id());
       h.clear();
       result = true;
     }
     return result;
   }

RunNumber_t art::DataViewImpl::run ( ) const

Definition at line 71 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.run();
   }

RunID art::DataViewImpl::runID ( ) const

Definition at line 50 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.runID();
   }

SubRunNumber_t art::DataViewImpl::subRun ( ) const

Definition at line 78 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.subRun();
   }

SubRunID art::DataViewImpl::subRunID ( ) const

Definition at line 57 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.subRunID();
   }

Timestamp art::DataViewImpl::time ( ) const

Definition at line 106 of file DataViewImpl.cc.

   {
     std::lock_guard lock{mutex_};
     return principal_.time();
   }

Friends And Related Function Documentation

friend class detail::Analyzer

friend

Definition at line 67 of file DataViewImpl.h.

friend class detail::Filter

friend

Definition at line 68 of file DataViewImpl.h.

friend class detail::Producer

friend

Definition at line 69 of file DataViewImpl.h.

friend class ProducingService

friend

Definition at line 71 of file DataViewImpl.h.

friend class ResultsProducer

friend

Definition at line 70 of file DataViewImpl.h.

Member Data Documentation

BranchType const art::DataViewImpl::branchType_

private

Definition at line 304 of file DataViewImpl.h.

ModuleContext const& art::DataViewImpl::mc_

private

Definition at line 310 of file DataViewImpl.h.

ModuleDescription const& art::DataViewImpl::md_

private

Definition at line 313 of file DataViewImpl.h.

std::recursive_mutex art::DataViewImpl::mutex_ {}

mutableprivate

Definition at line 301 of file DataViewImpl.h.

Principal const& art::DataViewImpl::principal_

private

Definition at line 307 of file DataViewImpl.h.

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

private

Definition at line 333 of file DataViewImpl.h.

RangeSet art::DataViewImpl::rangeSet_ {RangeSet::invalid()}

private

Definition at line 324 of file DataViewImpl.h.

bool const art::DataViewImpl::recordParents_

private

Definition at line 320 of file DataViewImpl.h.

std::set<ProductID> art::DataViewImpl::retrievedProducts_ {}

mutableprivate

Definition at line 329 of file DataViewImpl.h.

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

art/art/Framework/Principal/DataViewImpl.h
art/art/Framework/Principal/DataViewImpl.cc

Classes

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation