edm::detail Namespace Reference

Classes
struct	ElementType
struct	ElementType< edmNew::DetSetVector< T > >
struct	getMemberType
struct	getMemberType< std::vector< edm::Ptr< T > >, true >
struct	getMemberType< std::vector< std::unique_ptr< T, Deleter > >, true >
struct	getMemberType< T, false >
struct	getMemberType< T, true >
struct	GetProduct
struct	GetProduct< RefVector< C, T, F > >
struct	GetProduct< std::vector< std::unique_ptr< T, D >, A > >
struct	getValueType
struct	getValueType< T, false >
struct	getValueType< T, true >
struct	has_typedef_member_type
struct	has_typedef_member_type< std::vector< edm::Ptr< T > > >
struct	has_typedef_member_type< std::vector< std::unique_ptr< T, Deleter > > >
struct	has_typedef_value_type
struct	IsStdOptional
struct	IsStdOptional< std::optional< T > >
class	NamedEventSelector
class	StdArrayTrait
class	StdArrayTrait< T, 0 >
class	ThinnedOrSlimmedProduct
class	ThreadSafeRegistry
class	TriggerResultsBasedEventSelector

Typedefs
using	GetThinnedKeyFromExceptionFactory = std::function< edm::Exception()>
typedef edm::Handle< edm::TriggerResults >	handle_t
using	no_tag = std::false_type
using	yes_tag = std::true_type

Functions
void	_throw_range (det_id_type i)
void	annotateResolverMakerExceptionAndRethrow (cms::Exception &except, std::string const &modtype, ModuleTypeResolverBase const *resolver)
bool	configureEventSelector (edm::ParameterSet const &iPSet, std::string const &iProcessName, std::vector< std::string > const &iAllTriggerNames, edm::detail::TriggerResultsBasedEventSelector &oSelector, ConsumesCollector &&iC)
template<typename T >
void	do_post_insert_if_available (T &iProduct)
void	doTheOffset (int bunchSpace, int bcr, std::vector< SimTrack > &simtracks, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< SimVertex > &simvertices, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< PSimHit > &simhits, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< PCaloHit > &calohits, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, TrackingRecHitCollection &trackingrechits, unsigned int evtNr, int vertexOffset, bool wrap)
template<typename Item , typename Selector , typename Collection >
void	fillCollectionForThinning (Item const &item, Selector &selector, unsigned int iIndex, Collection &output, ThinnedAssociation &association)
template<typename F >
std::variant< unsigned int, GetThinnedKeyFromExceptionFactory, std::monostate >	getThinnedKeyFrom_implementation (ProductID const &parentID, BranchID const &parent, unsigned int key, ProductID const &thinnedID, BranchID thinned, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F &&getThinnedAssociation)
template<typename F1 , typename F2 , typename F3 >
std::optional< std::tuple< WrapperBase const *, unsigned int > >	getThinnedProduct (ProductID const &pid, unsigned int key, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID)
template<typename F1 , typename F2 , typename F3 >
ThinnedOrSlimmedProduct	getThinnedProductOnSlimmingDepth (ProductID const &pid, unsigned int key, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID)
template<typename F1 , typename F2 , typename F3 >
void	getThinnedProducts (ProductID const &pid, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID, std::vector< WrapperBase const *> &foundContainers, std::vector< unsigned int > &keys)
template<typename F1 , typename F2 , typename F3 >
std::optional< std::tuple< ThinnedAssociation const *, std::vector< unsigned int > > >	getThinnedProductsOnSlimmingDepth (ProductID const &pid, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID, std::vector< WrapperBase const *> &foundContainers, std::vector< unsigned int > &keys)
template<typename T >
static yes_tag	has_member_type (typename T::member_type *)
template<typename T >
static no_tag	has_member_type (...)
template<typename T >
static yes_tag	has_value_type (typename T::value_type *)
template<typename T >
static no_tag	has_value_type (...)
std::string const &	InvalidHash ()
auto	makeThinnedIndexes (std::vector< unsigned int > const &keys, std::vector< WrapperBase const *> const &foundContainers, ThinnedAssociation const *thinnedAssociation)
template<typename KEY , typename T , typename E >
std::ostream &	operator<< (std::ostream &os, ThreadSafeRegistry< KEY, T > const &reg)
void	processEDAliases (std::vector< std::string > const &aliasNamesToProcess, std::unordered_set< std::string > const &aliasModulesToProcess, ParameterSet const &proc_pset, std::string const &processName, ProductRegistry &preg)
template<typename COLLECTION >
void	reallyfillPtrVector (COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const *> &oPtr)
template<class COLLECTION >
void	reallyFillView (COLLECTION const &coll, ProductID const &id, std::vector< void const *> &ptrs, FillViewHelperVector &helpers)
template<typename COLLECTION >
void	reallySetPtr (COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
ParameterSetID	registerProperSelectionInfo (edm::ParameterSet const &iInitial, std::string const &iLabel, std::map< std::string, std::vector< std::pair< std::string, int > > > const &outputModulePathPositions, bool anyProductProduced)
template<typename TFactory , typename TCache >
auto	resolveMaker (std::string const &moduleType, ModuleTypeResolverMaker const *resolverMaker, edm::ParameterSet const &modulePSet, TCache &makerCache) -> typename TCache::mapped_type::element_type const *

Variables
constexpr unsigned int	kThinningDoNotLookForThisIndex = std::numeric_limits<unsigned int>::max()

Typedef Documentation

GetThinnedKeyFromExceptionFactory

typedef std::function< edm::Exception()> edm::detail::GetThinnedKeyFromExceptionFactory

Definition at line 37 of file EDProductGetter.h.

handle_t

typedef edm::Handle<edm::TriggerResults> edm::detail::handle_t

Definition at line 28 of file TriggerResultsBasedEventSelector.h.

no_tag

using edm::detail::no_tag = typedef std::false_type

Definition at line 22 of file WrapperDetail.h.

yes_tag

using edm::detail::yes_tag = typedef std::true_type

Definition at line 23 of file WrapperDetail.h.

Function Documentation

_throw_range()

void edm::detail::_throw_range ( det_id_type  i )

inline

Definition at line 69 of file DetSetVector.h.

References mps_fire::i, edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by edm::DetSetVector< TotemRPLocalTrack::FittedRecHit >::operator[]().

                                            {
      Exception::throwThis(
          errors::InvalidReference, "DetSetVector::operator[] called with index not in collection;\nindex value: ", i);
    }

annotateResolverMakerExceptionAndRethrow()

void edm::detail::annotateResolverMakerExceptionAndRethrow	(	cms::Exception &	except,
		std::string const &	modtype,
		ModuleTypeResolverBase const *	resolver
	)

Definition at line 4 of file resolverMaker.cc.

References cms::Exception::addAdditionalInfo(), eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by resolveMaker().

                                                                                        {
    if (not resolver) {
      throw except;
    }
    //if needed, create list of alternative types that were tried
    std::string alternativeTypes;
    auto index = resolver->kInitialIndex;
    auto newType = modtype;
    int tries = 0;
    do {
      ++tries;
      if (not alternativeTypes.empty()) {
        alternativeTypes.append(", ");
      }
      auto [ttype, tindex] = resolver->resolveType(std::move(newType), index);
      newType = std::move(ttype);
      index = tindex;
      alternativeTypes.append(newType);
    } while (index != resolver->kLastIndex);
    if (tries == 1 and alternativeTypes == modtype) {
      throw except;
    }
    alternativeTypes.insert(0, "These alternative types were tried: ");
    except.addAdditionalInfo(alternativeTypes);
    throw except;
  }

configureEventSelector()

bool edm::detail::configureEventSelector	(	edm::ParameterSet const &	iPSet,
		std::string const &	iProcessName,
		std::vector< std::string > const &	iAllTriggerNames,
		edm::detail::TriggerResultsBasedEventSelector &	oSelector,
		edm::ConsumesCollector &&	iC
	)

Handles the final initialization of the TriggerResutsBasedEventSelector

Returns

true if all events will be selected

Definition at line 43 of file TriggerResultsBasedEventSelector.cc.

References edm::ParameterSet::empty(), edm::ParameterSet::getParameter(), mps_fire::i, eostools::move(), trigger_results_based_event_selector_utils::parse_path_spec(), edm::detail::TriggerResultsBasedEventSelector::setup(), and edm::detail::TriggerResultsBasedEventSelector::setupDefault().

Referenced by edm::core::OutputModuleCore::doPreallocate_(), edm::core::OutputModuleCore::OutputModuleCore(), and edm::SubProcess::SubProcess().

                                                           {
      // If selectevents is an emtpy ParameterSet, then we are to write
      // all events, or one which contains a vstrig 'SelectEvents' that
      // is empty, we are to write all events. We have no need for any
      // EventSelectors.
      if (iPSet.empty()) {
        oSelector.setupDefault();
        return true;
      }

      std::vector<std::string> path_specs = iPSet.getParameter<std::vector<std::string> >("SelectEvents");

      if (path_specs.empty()) {
        oSelector.setupDefault();
        return true;
      }

      // If we get here, we have the possibility of having to deal with
      // path_specs that look at more than one process.
      std::vector<parsed_path_spec_t> parsed_paths(path_specs.size());
      for (size_t i = 0; i < path_specs.size(); ++i) {
        parse_path_spec(path_specs[i], parsed_paths[i]);
      }
      oSelector.setup(parsed_paths, iAllTriggerNames, iProcessName, std::move(iC));

      return false;
    }

do_post_insert_if_available()

template<typename T >

void edm::detail::do_post_insert_if_available

(

T &

iProduct

)

Definition at line 266 of file PrincipalGetAdapter.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), AlCaHLTBitMon_ParallelJobs::p, and edm::requires.

Referenced by edm::ProcessBlock::emplaceImpl(), edm::LuminosityBlock::emplaceImpl(), edm::Run::emplaceImpl(), edm::Event::emplaceImpl(), edm::ProcessBlock::putImpl(), edm::LuminosityBlock::putImpl(), edm::Run::putImpl(), and edm::Event::putImpl().

                                                  {
      if constexpr (not std::derived_from<T, DoNotSortUponInsertion> and requires(T& p) { p.post_insert(); }) {
        iProduct.post_insert();
      }
    }

doTheOffset() [1/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< SimTrack > &	simtracks,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 7 of file Adjuster.cc.

References l1ctLayer2EG_cff::id, and B2GTnPMonitor_cfi::item.

Referenced by edm::Adjuster< T >::doOffset().

                                                                                                                  {
      EncodedEventId id(bcr, evtNr);
      for (auto& item : simtracks) {
        item.setEventId(id);
        if (!item.noVertex()) {
          item.setVertexIndex(item.vertIndex() + vertexOffset);
        }
      }
    }

doTheOffset() [2/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< SimVertex > &	simvertices,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 18 of file Adjuster.cc.

References l1ctLayer2EG_cff::id, B2GTnPMonitor_cfi::item, and simBeamSpotPI::timeOffset.

                                                                                                                     {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      for (auto& item : simvertices) {
        item.setEventId(id);
        item.setTof(item.position().t() + timeOffset);
      }
    }

doTheOffset() [3/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< PSimHit > &	simhits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 28 of file Adjuster.cc.

References l1ctLayer2EG_cff::id, createfilelist::int, B2GTnPMonitor_cfi::item, HLTBitAnalyser_cfi::simhits, simBeamSpotPI::timeOffset, and edm::convertException::wrap().

                                                                                                               {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      if (wrap) {  // wrap time for long-lived hits into one beam crossing
        for (auto& item : simhits) {
          item.setEventId(id);

          float Tfloor = floor(item.timeOfFlight());
          float digits = item.timeOfFlight() - Tfloor;
          int remainder = int(Tfloor) % bunchSpace;
          item.setTof(float(remainder) + digits + timeOffset);
        }
      } else {
        for (auto& item : simhits) {
          item.setEventId(id);
          item.setTof(item.timeOfFlight() + timeOffset);
        }
      }
    }

doTheOffset() [4/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< PCaloHit > &	calohits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 49 of file Adjuster.cc.

References l1ctLayer2EG_cff::id, B2GTnPMonitor_cfi::item, and simBeamSpotPI::timeOffset.

                                                                                                                 {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      for (auto& item : calohits) {
        item.setEventId(id);
        item.setTime(item.time() + timeOffset);
      }
    }

doTheOffset() [5/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		TrackingRecHitCollection &	trackingrechits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 59 of file Adjuster.cc.

References edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::end(), l1ctLayer2EG_cff::id, trackerHitRTTI::isFast(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, nano_mu_digi_cff::rawId, and FastTrackerRecHit::setEventId().

                                {
      EncodedEventId id(bcr, evtNr);
      for (auto it = trackingrechits.begin(); it != trackingrechits.end(); ++it) {
        if (trackerHitRTTI::isFast(*it)) {
          FastTrackerRecHit* rechit = static_cast<FastTrackerRecHit*>(&(*it));
          rechit->setEventId(id.rawId());
        }
      }
    }

fillCollectionForThinning()

template<typename Item , typename Selector , typename Collection >

void edm::detail::fillCollectionForThinning	(	Item const &	item,
		Selector &	selector,
		unsigned int	iIndex,
		Collection &	output,
		ThinnedAssociation &	association
	)

Definition at line 43 of file ThinningProducer.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), B2GTnPMonitor_cfi::item, eostools::move(), getGTfromDQMFile::obj, collectionMerger::selector, and mitigatedMETSequence_cff::U.

Referenced by edmNew::fillCollectionForThinning(), and edm::ThinningProducer< Collection, Selector >::produce().

                                                                    {
      using SelectorChooseReturnType = decltype(selector.choose(0U, std::declval<Item const&>()));
      constexpr bool isSlimming = detail::IsStdOptional<SelectorChooseReturnType>::value;
      if constexpr (isSlimming) {
        std::optional<typename SelectorChooseReturnType::value_type> obj = selector.choose(iIndex, item);
        if (obj.has_value()) {
          // move to support std::unique_ptr<T> with edm::OwnVector<T> or std::vector<unique_ptr<T>>
          output.push_back(std::move(*obj));
          association.push_back(iIndex);
        }
      } else {
        if (selector.choose(iIndex, item)) {
          output.push_back(item);
          association.push_back(iIndex);
        }
      }
    }

getThinnedKeyFrom_implementation()

template<typename F >

std::variant<unsigned int, GetThinnedKeyFromExceptionFactory, std::monostate> edm::detail::getThinnedKeyFrom_implementation	(	ProductID const &	parentID,
		BranchID const &	parent,
		unsigned int	key,
		ProductID const &	thinnedID,
		BranchID	thinned,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F &&	getThinnedAssociation
	)

Definition at line 395 of file getThinned_implementation.h.

References edm::ThinnedAssociationsHelper::begin(), edm::ThinnedAssociationsHelper::end(), Exception, edm::errors::InvalidReference, submitPVResolutionJobs::key, edm::errors::LogicError, or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), and edm::ThinnedAssociationsHelper::parentEnd().

Referenced by fwlite::DataGetterHelper::getThinnedKeyFrom(), BareRootProductGetterBase::getThinnedKeyFrom(), and edm::EventPrincipal::getThinnedKeyFrom().

                                   {
      // need to explicitly check for equality of parent BranchID,
      // because ThinnedAssociationsHelper::parentBegin() uses
      // std::lower_bound() that returns a valid iterator in case the
      // parent is not found
      if (auto iParent = thinnedAssociationsHelper.parentBegin(parent);
          iParent == thinnedAssociationsHelper.parentEnd(parent) or iParent->parent() != parent) {
        return [parentID]() {
          return Exception(errors::InvalidReference)
                 << "Parent collection with ProductID " << parentID << " has not been thinned";
        };
      }

      bool foundParent = false;
      std::vector<ThinnedAssociation const*> thinnedAssociationParentage;
      while (not foundParent) {
        // TODO: be smarter than linear search every time?
        auto branchesToThinned = std::find_if(
            thinnedAssociationsHelper.begin(), thinnedAssociationsHelper.end(), [&thinned](auto& associatedBranches) {
              return associatedBranches.thinned() == thinned;
            });
        if (branchesToThinned == thinnedAssociationsHelper.end()) {
          return [parentID, thinnedID, thinnedIsThinned = not thinnedAssociationParentage.empty()]() {
            Exception ex(errors::InvalidReference);
            ex << "Requested thinned collection with ProductID " << thinnedID
               << " is not thinned from the parent collection with ProductID " << parentID
               << " or from any collection thinned from it.";
            if (not thinnedIsThinned) {
              ex << " In fact, the collection " << thinnedID
                 << " passed in as a 'thinned' collection has not been thinned at all.";
            }
            return ex;
          };
        }

        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(branchesToThinned->association());
        if (thinnedAssociation == nullptr) {
          Exception ex{errors::LogicError};
          if (thinnedAssociationParentage.empty()) {
            ex << "ThinnedAssociation corresponding to thinned collection with ProductID " << thinnedID
               << " not found.";
          } else {
            ex << "Intermediate ThinnedAssociation between the requested thinned ProductID " << thinnedID
               << " and parent " << parentID << " not found.";
          }
          ex << " This should not happen.\nPlease contact the core framework developers.";
          throw ex;
        }

        thinnedAssociationParentage.push_back(thinnedAssociation);
        if (branchesToThinned->parent() == parent) {
          foundParent = true;
        } else {
          // next iteration with current parent as the thinned collection
          thinned = branchesToThinned->parent();
        }
      }

      // found the parent, now need to rewind the parentage chain to
      // find the index in the requested thinned collection
      unsigned int thinnedIndex = key;
      for (auto iAssociation = thinnedAssociationParentage.rbegin(), iEnd = thinnedAssociationParentage.rend();
           iAssociation != iEnd;
           ++iAssociation) {
        auto optIndex = (*iAssociation)->getThinnedIndex(thinnedIndex);
        if (optIndex) {
          thinnedIndex = *optIndex;
        } else {
          return std::monostate{};
        }
      }
      return thinnedIndex;
    }

getThinnedProduct()

template<typename F1 , typename F2 , typename F3 >

std::optional<std::tuple<WrapperBase const*, unsigned int> > edm::detail::getThinnedProduct	(	ProductID const &	pid,
		unsigned int	key,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID
	)

Definition at line 288 of file getThinned_implementation.h.

References getThinnedProductOnSlimmingDepth(), submitPVResolutionJobs::key, and mkLumiAveragedPlots::tuple.

Referenced by BareRootProductGetterBase::getThinnedProduct(), fwlite::DataGetterHelper::getThinnedProduct(), and edm::EventPrincipal::getThinnedProduct().

                           {
      auto thinnedOrSlimmed = getThinnedProductOnSlimmingDepth(
          pid, key, thinnedAssociationsHelper, pidToBid, getThinnedAssociation, getByProductID);

      if (thinnedOrSlimmed.hasThinned()) {
        return thinnedOrSlimmed.thinnedProduct();
      } else if (thinnedOrSlimmed.hasSlimmed()) {
        auto [slimmedAssociation, slimmedIndex] = thinnedOrSlimmed.slimmedAssociation();
        ProductID const& slimmedCollectionPID = slimmedAssociation->thinnedCollectionID();
        WrapperBase const* slimmedCollection = getByProductID(slimmedCollectionPID);
        if (slimmedCollection == nullptr) {
          // Slimmed container is not found, try looking recursively in thinned containers
          // which were made by selecting elements from this thinned container.
          return getThinnedProduct(slimmedCollectionPID,
                                   slimmedIndex,
                                   thinnedAssociationsHelper,
                                   pidToBid,
                                   getThinnedAssociation,
                                   getByProductID);
        }
        return std::tuple(slimmedCollection, slimmedIndex);
      }
      return std::nullopt;
    }

getThinnedProductOnSlimmingDepth()

template<typename F1 , typename F2 , typename F3 >

ThinnedOrSlimmedProduct edm::detail::getThinnedProductOnSlimmingDepth	(	ProductID const &	pid,
		unsigned int	key,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID
	)

Definition at line 68 of file getThinned_implementation.h.

References edm::ThinnedAssociation::getThinnedIndex(), submitPVResolutionJobs::key, or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), and edm::ThinnedAssociation::thinnedCollectionID().

Referenced by getThinnedProduct().

                                                                                {
      BranchID parent = pidToBid(pid);

      auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent);
      auto const iEnd = thinnedAssociationsHelper.parentEnd(parent);

      if (associatedBranches == iEnd) {
        return ThinnedOrSlimmedProduct();
      }
      bool const slimmedAllowed = (associatedBranches + 1 == iEnd);
      if (slimmedAllowed and associatedBranches->isSlimmed()) {
        // Slimmed container can be considered only if it has no (thinned) siblings
        ThinnedAssociation const* slimmedAssociation = getThinnedAssociation(associatedBranches->association());
        if (slimmedAssociation == nullptr or
            associatedBranches->parent() != pidToBid(slimmedAssociation->parentCollectionID())) {
          return ThinnedOrSlimmedProduct();
        }

        // Does this slimmed container have the element referenced by key?
        auto slimmedIndex = slimmedAssociation->getThinnedIndex(key);
        if (slimmedIndex.has_value()) {
          return ThinnedOrSlimmedProduct(slimmedAssociation, *slimmedIndex);
        } else {
          return ThinnedOrSlimmedProduct();
        }
      }

      // Loop over thinned containers which were made by selecting elements from the parent container
      for (; associatedBranches != iEnd; ++associatedBranches) {
        if (associatedBranches->isSlimmed()) {
          continue;
        }

        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
        if (thinnedAssociation == nullptr)
          continue;

        if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
          continue;
        }

        // Does this thinned container have the element referenced by key?
        auto thinnedIndex = thinnedAssociation->getThinnedIndex(key);
        if (not thinnedIndex.has_value()) {
          continue;
        }

        // Return a pointer to thinned container if we can find it
        ProductID const& thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
        WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID);
        if (thinnedCollection != nullptr) {
          return ThinnedOrSlimmedProduct(thinnedCollection, *thinnedIndex);
        }

        // Thinned container is not found, try looking recursively in thinned containers
        // which were made by selecting elements from this thinned container.
        auto thinnedOrSlimmed = getThinnedProductOnSlimmingDepth(thinnedCollectionPID,
                                                                 *thinnedIndex,
                                                                 thinnedAssociationsHelper,
                                                                 pidToBid,
                                                                 getThinnedAssociation,
                                                                 getByProductID);
        if (thinnedOrSlimmed.hasThinned() or (slimmedAllowed and thinnedOrSlimmed.hasSlimmed())) {
          return thinnedOrSlimmed;
        }
      }

      return ThinnedOrSlimmedProduct();
    }

getThinnedProducts()

template<typename F1 , typename F2 , typename F3 >

void edm::detail::getThinnedProducts	(	ProductID const &	pid,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID,
		std::vector< WrapperBase const *> &	foundContainers,
		std::vector< unsigned int > &	keys
	)

Definition at line 335 of file getThinned_implementation.h.

References getThinnedProductsOnSlimmingDepth(), dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, and eostools::move().

Referenced by fwlite::DataGetterHelper::getThinnedProducts(), BareRootProductGetterBase::getThinnedProducts(), and edm::EventPrincipal::getThinnedProducts().

                                                           {
      auto slimmed = getThinnedProductsOnSlimmingDepth(
          pid, thinnedAssociationsHelper, pidToBid, getThinnedAssociation, getByProductID, foundContainers, keys);
      if (slimmed.has_value()) {
        // no thinned procucts found, try out slimmed next if one is available
        auto [slimmedAssociation, slimmedIndexes] = std::move(*slimmed);
        ProductID const& slimmedCollectionPID = slimmedAssociation->thinnedCollectionID();
        WrapperBase const* slimmedCollection = getByProductID(slimmedCollectionPID);
        unsigned const nKeys = keys.size();
        if (slimmedCollection == nullptr) {
          getThinnedProducts(slimmedCollectionPID,
                             thinnedAssociationsHelper,
                             pidToBid,
                             getThinnedAssociation,
                             getByProductID,
                             foundContainers,
                             slimmedIndexes);
          for (unsigned k = 0; k < nKeys; ++k) {
            if (foundContainers[k] == nullptr)
              continue;
            if (slimmedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = slimmedIndexes[k];
          }
        } else {
          for (unsigned k = 0; k < nKeys; ++k) {
            if (slimmedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = slimmedIndexes[k];
            foundContainers[k] = slimmedCollection;
          }
        }
      }
    }

getThinnedProductsOnSlimmingDepth()

template<typename F1 , typename F2 , typename F3 >

std::optional<std::tuple<ThinnedAssociation const*, std::vector<unsigned int> > > edm::detail::getThinnedProductsOnSlimmingDepth	(	ProductID const &	pid,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID,
		std::vector< WrapperBase const *> &	foundContainers,
		std::vector< unsigned int > &	keys
	)

Definition at line 188 of file getThinned_implementation.h.

References dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, makeThinnedIndexes(), eostools::move(), or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), edm::ThinnedAssociation::thinnedCollectionID(), and mkLumiAveragedPlots::tuple.

Referenced by getThinnedProducts().

                                       {
      BranchID parent = pidToBid(pid);

      auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent);
      auto const iEnd = thinnedAssociationsHelper.parentEnd(parent);

      if (associatedBranches == iEnd) {
        return std::nullopt;
      }
      bool const slimmedAllowed = associatedBranches + 1 == iEnd;
      if (slimmedAllowed and associatedBranches->isSlimmed()) {
        // Slimmed container can be considered only if it has no (thinned) siblings
        ThinnedAssociation const* slimmedAssociation = getThinnedAssociation(associatedBranches->association());
        if (slimmedAssociation == nullptr or
            associatedBranches->parent() != pidToBid(slimmedAssociation->parentCollectionID())) {
          return std::nullopt;
        }

        auto [slimmedIndexes, hasAny] = makeThinnedIndexes(keys, foundContainers, slimmedAssociation);
        // Does this slimmed container have any of the elements referenced by keys?
        if (hasAny) {
          return std::tuple(slimmedAssociation, std::move(slimmedIndexes));
        } else {
          return std::nullopt;
        }
      }

      // Loop over thinned containers which were made by selecting elements from the parent container
      for (; associatedBranches != iEnd; ++associatedBranches) {
        if (associatedBranches->isSlimmed()) {
          continue;
        }

        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
        if (thinnedAssociation == nullptr)
          continue;

        if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
          continue;
        }

        auto [thinnedIndexes, hasAny] = makeThinnedIndexes(keys, foundContainers, thinnedAssociation);
        if (!hasAny) {
          continue;
        }

        // Set the pointers and indexes into the thinned container (if we can find it)
        ProductID thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
        WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID);
        unsigned const nKeys = keys.size();
        if (thinnedCollection == nullptr) {
          // Thinned container is not found, try looking recursively in thinned containers
          // which were made by selecting elements from this thinned container.
          auto slimmed = getThinnedProductsOnSlimmingDepth(thinnedCollectionPID,
                                                           thinnedAssociationsHelper,
                                                           pidToBid,
                                                           getThinnedAssociation,
                                                           getByProductID,
                                                           foundContainers,
                                                           thinnedIndexes);
          if (slimmedAllowed and slimmed.has_value()) {
            return slimmed;
          }
          for (unsigned k = 0; k < nKeys; ++k) {
            if (foundContainers[k] == nullptr)
              continue;
            if (thinnedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = thinnedIndexes[k];
          }
        } else {
          for (unsigned k = 0; k < nKeys; ++k) {
            if (thinnedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = thinnedIndexes[k];
            foundContainers[k] = thinnedCollection;
          }
        }
      }
      return std::nullopt;
    }

has_member_type() [1/2]

template<typename T >

static yes_tag edm::detail::has_member_type ( typename T::member_type *  )

static

has_member_type() [2/2]

template<typename T >

static no_tag edm::detail::has_member_type (   ... )

static

has_value_type() [1/2]

template<typename T >

static yes_tag edm::detail::has_value_type ( typename T::value_type *  )

static

has_value_type() [2/2]

template<typename T >

static no_tag edm::detail::has_value_type (   ... )

static

InvalidHash()

std::string const & edm::detail::InvalidHash

(

)

Definition at line 11 of file Hash.cc.

References cms::MD5Result::compactForm(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::hash_detail::isValid_(), and edm::Hash< EntryDescriptionType >::reset().

                                   {
      static std::string const invalid = cms::MD5Result().compactForm();
      return invalid;
    }

makeThinnedIndexes()

auto edm::detail::makeThinnedIndexes ( std::vector< unsigned int > const &  keys, std::vector< WrapperBase const *> const &  foundContainers, ThinnedAssociation const *  thinnedAssociation  )

inline

Definition at line 143 of file getThinned_implementation.h.

References edm::ThinnedAssociation::getThinnedIndex(), dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, eostools::move(), and mkLumiAveragedPlots::tuple.

Referenced by getThinnedProductsOnSlimmingDepth().

                                                                                 {
      unsigned const nKeys = keys.size();
      std::vector<unsigned int> thinnedIndexes(nKeys, kThinningDoNotLookForThisIndex);
      bool hasAny = false;
      for (unsigned k = 0; k < nKeys; ++k) {
        // Already found this one
        if (foundContainers[k] != nullptr) {
          continue;
        }
        // Already know this one is not in this thinned container
        if (keys[k] == kThinningDoNotLookForThisIndex) {
          continue;
        }
        // Does the thinned container hold the entry of interest?
        if (auto thinnedIndex = thinnedAssociation->getThinnedIndex(keys[k]); thinnedIndex.has_value()) {
          thinnedIndexes[k] = *thinnedIndex;
          hasAny = true;
        }
      }
      return std::tuple(std::move(thinnedIndexes), hasAny);
    }

operator<<()

template<typename KEY , typename T , typename E >

std::ostream& edm::detail::operator<< ( std::ostream &  os, ThreadSafeRegistry< KEY, T > const &  reg  )

inline

Definition at line 97 of file ThreadSafeRegistry.h.

References l1tGTMenu_BTagSeeds_cff::os.

                                                                                         {
      reg.print(os);
      return os;
    }

processEDAliases()

void edm::detail::processEDAliases	(	std::vector< std::string > const &	aliasNamesToProcess,
		std::unordered_set< std::string > const &	aliasModulesToProcess,
		ParameterSet const &	proc_pset,
		std::string const &	processName,
		ProductRegistry &	preg
	)

Process and insert EDAliases to ProductRegistry

Processes only those EDAliases whose names are given in aliasNamesToProcess. If aliasModulesToProcess is not empty, only those alias branches that point to modules named in aliasModulesToProcess are processed.

Definition at line 90 of file processEDAliases.cc.

References edm::ProductRegistry::addLabelAlias(), SiStripOfflineCRack_cfg::alias, cms::cuda::assert(), edm::errors::Configuration, submitPVResolutionJobs::desc, relativeConstraints::empty, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getParameterSet(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, HerwigMaxPtPartonFilter_cfi::moduleLabel, SimL1EmulatorRepack_CalouGT_cff::processName, dumpMFGeometry_cfg::prod, edm::ProductRegistry::productList(), muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::Schedule::finishSetup(), and edm::ConditionalTaskHelper::processSwitchEDAliases().

                                                 {
      if (aliasNamesToProcess.empty()) {
        return;
      }
      std::string const star("*");
      std::string const empty("");
      ParameterSetDescription desc;
      desc.add<std::string>("type");
      desc.add<std::string>("fromProductInstance", star);
      desc.add<std::string>("toProductInstance", star);

      std::multimap<BranchKey, BranchKey> aliasMap;

      std::map<BranchKey, BranchKey> aliasKeys;  // Used to search for duplicates or clashes.

      // Auxiliary search structure to support wildcard for friendlyClassName
      std::multimap<std::string, BranchKey> moduleLabelToBranches;
      for (auto const& prod : preg.productList()) {
        if (processName == prod.second.processName()) {
          moduleLabelToBranches.emplace(prod.first.moduleLabel(), prod.first);
        }
      }

      // Now, loop over the alias information and store it in aliasMap.
      for (std::string const& alias : aliasNamesToProcess) {
        ParameterSet const& aliasPSet = proc_pset.getParameterSet(alias);
        std::vector<std::string> vPSetNames = aliasPSet.getParameterNamesForType<VParameterSet>();
        for (std::string const& moduleLabel : vPSetNames) {
          if (not aliasModulesToProcess.empty() and
              aliasModulesToProcess.find(moduleLabel) == aliasModulesToProcess.end()) {
            continue;
          }

          VParameterSet vPSet = aliasPSet.getParameter<VParameterSet>(moduleLabel);
          for (ParameterSet& pset : vPSet) {
            desc.validate(pset);
            std::string friendlyClassName = pset.getParameter<std::string>("type");
            std::string productInstanceName = pset.getParameter<std::string>("fromProductInstance");
            std::string instanceAlias = pset.getParameter<std::string>("toProductInstance");

            if (friendlyClassName == star) {
              bool processHasLabel = false;
              bool match = false;
              for (auto it = moduleLabelToBranches.lower_bound(moduleLabel);
                   it != moduleLabelToBranches.end() && it->first == moduleLabel;
                   ++it) {
                processHasLabel = true;
                if (productInstanceName != star and productInstanceName != it->second.productInstanceName()) {
                  continue;
                }
                match = true;

                checkAndInsertAlias(it->second.friendlyClassName(),
                                    moduleLabel,
                                    it->second.productInstanceName(),
                                    processName,
                                    alias,
                                    instanceAlias,
                                    preg,
                                    aliasMap,
                                    aliasKeys);
              }
              if (not match and processHasLabel) {
                // No product was found matching the alias.
                // We throw an exception only if a module with the specified module label was created in this process.
                // Note that if that condition is ever relatex, it  might be best to throw an exception with different
                // message (omitting productInstanceName) in case 'productInstanceName == start'
                throw Exception(errors::Configuration, "EDAlias parameter set mismatch\n")
                    << "There are no products with module label '" << moduleLabel << "' and product instance name '"
                    << productInstanceName << "'.\n";
              }
            } else if (productInstanceName == star) {
              bool match = false;
              BranchKey lowerBound(friendlyClassName, moduleLabel, empty, empty);
              for (ProductRegistry::ProductList::const_iterator it = preg.productList().lower_bound(lowerBound);
                   it != preg.productList().end() && it->first.friendlyClassName() == friendlyClassName &&
                   it->first.moduleLabel() == moduleLabel;
                   ++it) {
                if (it->first.processName() != processName) {
                  continue;
                }
                match = true;

                checkAndInsertAlias(friendlyClassName,
                                    moduleLabel,
                                    it->first.productInstanceName(),
                                    processName,
                                    alias,
                                    instanceAlias,
                                    preg,
                                    aliasMap,
                                    aliasKeys);
              }
              if (!match) {
                // No product was found matching the alias.
                // We throw an exception only if a module with the specified module label was created in this process.
                for (auto const& product : preg.productList()) {
                  if (moduleLabel == product.first.moduleLabel() && processName == product.first.processName()) {
                    throw Exception(errors::Configuration, "EDAlias parameter set mismatch\n")
                        << "There are no products of type '" << friendlyClassName << "'\n"
                        << "with module label '" << moduleLabel << "'.\n";
                  }
                }
              }
            } else {
              checkAndInsertAlias(friendlyClassName,
                                  moduleLabel,
                                  productInstanceName,
                                  processName,
                                  alias,
                                  instanceAlias,
                                  preg,
                                  aliasMap,
                                  aliasKeys);
            }
          }
        }
      }

      // Now add the new alias entries to the product registry.
      for (auto const& aliasEntry : aliasMap) {
        // Then check that the alias-for product exists
        ProductRegistry::ProductList::const_iterator it = preg.productList().find(aliasEntry.first);
        assert(it != preg.productList().end());
        preg.addLabelAlias(it->second, aliasEntry.second.moduleLabel(), aliasEntry.second.productInstanceName());
      }
    }

reallyfillPtrVector()

template<typename COLLECTION >

void edm::detail::reallyfillPtrVector	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const *> &	oPtr
	)

Definition at line 37 of file fillPtrVector.h.

References edm::detail::GetProduct< COLLECTION >::address(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::errors::LogicError, Skims_PA_cff::name, edm::pointerToBase(), and edm::Exception::throwThis().

Referenced by edm::fillPtrVector(), edm::SortedCollection< EcalRecHit >::fillPtrVector(), and edm::OwnVector< LayerWithHits >::fillPtrVector().

                                                           {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;

      oPtr.reserve(iIndicies.size());
      if (iToType == typeid(element_type)) {
        for (std::vector<unsigned long>::const_iterator itIndex = iIndicies.begin(), itEnd = iIndicies.end();
             itIndex != itEnd;
             ++itIndex) {
          iter it = coll.begin();
          std::advance(it, *itIndex);
          element_type const* address = GetProduct<product_type>::address(it);
          oPtr.push_back(address);
        }
      } else {
        for (std::vector<unsigned long>::const_iterator itIndex = iIndicies.begin(), itEnd = iIndicies.end();
             itIndex != itEnd;
             ++itIndex) {
          iter it = coll.begin();
          std::advance(it, *itIndex);
          element_type const* address = GetProduct<product_type>::address(it);
          void const* ptr = pointerToBase(iToType, address);
          if (nullptr != ptr) {
            oPtr.push_back(ptr);
          } else {
            Exception::throwThis(errors::LogicError,
                                 "TypeConversionError "
                                 "edm::PtrVector<> : unable to convert type ",
                                 typeid(element_type).name(),
                                 " to ",
                                 iToType.name(),
                                 "\n");
          }
        }
      }
    }

reallyFillView()

template<class COLLECTION >

void edm::detail::reallyFillView	(	COLLECTION const &	coll,
		ProductID const &	id,
		std::vector< void const *> &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 25 of file FillView.h.

References edm::detail::GetProduct< COLLECTION >::address(), MillePedeFileConverter_cfg::e, mps_fire::i, and submitPVResolutionJobs::key.

Referenced by edm::fillView(), edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::fillView(), edm::SortedCollection< EcalRecHit >::fillView(), and edm::DetSetVector< TotemRPLocalTrack::FittedRecHit >::fillView().

                                                       {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;
      typedef typename product_type::size_type size_type;

      ptrs.reserve(ptrs.size() + coll.size());
      helpers.reserve(ptrs.size() + coll.size());
      size_type key = 0;
      for (iter i = coll.begin(), e = coll.end(); i != e; ++i, ++key) {
        element_type const* address = GetProduct<product_type>::address(i);
        ptrs.push_back(address);
        helpers.emplace_back(id, key);
      }
    }

reallySetPtr()

template<typename COLLECTION >

void edm::detail::reallySetPtr	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 36 of file setPtr.h.

References edm::detail::GetProduct< COLLECTION >::address(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::errors::LogicError, Skims_PA_cff::name, edm::pointerToBase(), and edm::Exception::throwThis().

Referenced by edm::setPtr(), and edm::SortedCollection< EcalRecHit >::setPtr().

                                                                                                                    {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;

      if (iToType == typeid(element_type)) {
        iter it = coll.begin();
        std::advance(it, iIndex);
        element_type const* address = GetProduct<product_type>::address(it);
        oPtr = address;
      } else {
        iter it = coll.begin();
        std::advance(it, iIndex);
        element_type const* address = GetProduct<product_type>::address(it);

        oPtr = pointerToBase(iToType, address);

        if (nullptr == oPtr) {
          Exception::throwThis(errors::LogicError,
                               "TypeConversionError"
                               "edm::Ptr<> : unable to convert type ",
                               typeid(element_type).name(),
                               " to ",
                               iToType.name(),
                               "\n");
        }
      }
    }

registerProperSelectionInfo()

ParameterSetID edm::detail::registerProperSelectionInfo	(	edm::ParameterSet const &	iInitial,
		std::string const &	iLabel,
		std::map< std::string, std::vector< std::pair< std::string, int > > > const &	outputModulePathPositions,
		bool	anyProductProduced
	)

Takes the user specified SelectEvents PSet and creates a new one which conforms to the canonical format required for provenance

Definition at line 126 of file TriggerResultsBasedEventSelector.cc.

References edm::ParameterSet::addParameter(), cms::cuda::assert(), edm::ParameterSet::copyForModify(), edm::ParameterSet::exists(), edm::ParameterSet::id(), B2GTnPMonitor_cfi::item, and edm::ParameterSet::registerIt().

Referenced by edm::core::OutputModuleCore::setEventSelectionInfo(), and edm::SubProcess::SubProcess().

                                 {
      ParameterSet selectEventsInfo;
      selectEventsInfo.copyForModify(iInitial);
      selectEventsInfo.addParameter<bool>("InProcessHistory", anyProductProduced);
      std::vector<std::string> endPaths;
      std::vector<int> endPathPositions;

      // The label will be empty if and only if this is a SubProcess
      // SubProcess's do not appear on any end path
      if (!iLabel.empty()) {
        std::map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator iter =
            outputModulePathPositions.find(iLabel);
        assert(iter != outputModulePathPositions.end());
        for (auto const& item : iter->second) {
          endPaths.push_back(item.first);
          endPathPositions.push_back(item.second);
        }
      }
      selectEventsInfo.addParameter<std::vector<std::string> >("EndPaths", endPaths);
      selectEventsInfo.addParameter<std::vector<int> >("EndPathPositions", endPathPositions);
      if (!selectEventsInfo.exists("SelectEvents")) {
        selectEventsInfo.addParameter<std::vector<std::string> >("SelectEvents", std::vector<std::string>());
      }
      selectEventsInfo.registerIt();

      return selectEventsInfo.id();
    }

resolveMaker()

template<typename TFactory , typename TCache >

auto edm::detail::resolveMaker	(	std::string const &	moduleType,
		ModuleTypeResolverMaker const *	resolverMaker,
		edm::ParameterSet const &	modulePSet,
		TCache &	makerCache
	)		-> typename TCache::mapped_type::element_type const*

Definition at line 20 of file resolveMaker.h.

References annotateResolverMakerExceptionAndRethrow(), beamerCreator::create(), newFWLiteAna::found, get, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, visualization-live-secondInstance_cfg::m, eostools::move(), and summarizeEdmComparisonLogfiles::succeeded.

                                                                                         {
    if (resolverMaker) {
      auto resolver = resolverMaker->makeResolver(modulePSet);
      auto index = resolver->kInitialIndex;
      auto newType = moduleType;
      do {
        auto [ttype, tindex] = resolver->resolveType(std::move(newType), index);
        newType = std::move(ttype);
        index = tindex;
        // try the maker cache first
        auto found = makerCache.find(newType);
        if (found != makerCache.end()) {
          return found->second.get();
        }

        // if not in cache, then try to create
        auto m = TFactory::get()->tryToCreate(newType);
        if (m) {
          //FDEBUG(1) << "Factory:  created worker of type " << newType << std::endl;
          auto [it, succeeded] = makerCache.emplace(newType, std::move(m));
          if (not succeeded) {
            return nullptr;
          }
          return it->second.get();
        }
        // not found, try next one
      } while (index != resolver->kLastIndex);
      try {
        //failed to find a plugin
        auto m = TFactory::get()->create(moduleType);
        return nullptr;  // dummy return, the create() call throws an exception
      } catch (cms::Exception& iExcept) {
        detail::annotateResolverMakerExceptionAndRethrow(iExcept, moduleType, resolver.get());
      }
    }
    auto [it, succeeded] = makerCache.emplace(moduleType, TFactory::get()->create(moduleType));
    //FDEBUG(1) << "Factory:  created worker of type " << moduleType << std::endl;
    if (not succeeded) {
      return nullptr;
    }
    return it->second.get();
  }

Variable Documentation

kThinningDoNotLookForThisIndex

constexpr unsigned int edm::detail::kThinningDoNotLookForThisIndex = std::numeric_limits<unsigned int>::max()

Definition at line 22 of file getThinned_implementation.h.

Referenced by getThinnedProducts(), getThinnedProductsOnSlimmingDepth(), and makeThinnedIndexes().