edm::RefCore Class Reference

#include <RefCore.h>

Public Member Functions
WrapperBase const *	getProductPtr (std::type_info const &type, EDProductGetter const *prodGetter) const
WrapperBase const *	getThinnedProductPtr (std::type_info const &type, unsigned int &thinnedKey, EDProductGetter const *prodGetter) const
ProductID	id () const
bool	isAvailable () const
bool	isNonnull () const
bool	isNull () const
bool	isThinnedAvailable (unsigned int thinnedKey, EDProductGetter const *prodGetter) const
bool	isTransient () const
int	isTransientInt () const
void	nullPointerForTransientException (std::type_info const &type) const
bool	operator! () const
RefCore &	operator= (RefCore const &)
RefCore &	operator= (RefCore &&iOther) noexcept
EDProductGetter const *	productGetter () const
void	productNotFoundException (std::type_info const &type) const
void const *	productPtr () const
void	pushBackItem (RefCore const &productToBeInserted, bool checkPointer)
void	pushBackRefItem (RefCore const &productToBeInserted)
	RefCore ()
	RefCore (ProductID const &theId, void const *prodPtr, EDProductGetter const *prodGetter, bool transient)
	RefCore (RefCore const &)
	RefCore (RefCore &&iOther) noexcept
void	setProductGetter (EDProductGetter const *prodGetter) const
void	setProductPtr (void const *prodPtr) const
void	swap (RefCore &) noexcept
WrapperBase const *	tryToGetProductPtr (std::type_info const &type, EDProductGetter const *prodGetter) const
bool	tryToSetProductPtrForFirstTime (void const *prodPtr) const
void	wrongTypeException (std::type_info const &expectedType, std::type_info const &actualType) const
	~RefCore () noexcept

Private Member Functions
bool	cachePtrIsInvalid () const
	RefCore (void const *iCache, ProcessIndex iProcessIndex, ProductIndex iProductIndex)
void	setCacheIsProductGetter (EDProductGetter const *iGetter) const
void	setCacheIsProductPtr (const void *iItem) const
void	setId (ProductID const &iId)
void	setTransient ()

Private Attributes
std::atomic< void const * >	cachePtr_
ProcessIndex	processIndex_
ProductIndex	productIndex_

Friends
class	RefCoreWithIndex

Detailed Description

Definition at line 21 of file RefCore.h.

Constructor & Destructor Documentation

edm::RefCore::RefCore ( )

inline

Definition at line 26 of file RefCore.h.

References operator=().

:  cachePtr_(nullptr),processIndex_(0),productIndex_(0){}

edm::RefCore::RefCore	(	ProductID const &	theId,
		void const *	prodPtr,
		EDProductGetter const *	prodGetter,
		bool	transient
	)

Definition at line 34 of file RefCore.cc.

References setCacheIsProductGetter(), and setTransient().

                                                                                                                 :
      cachePtr_(prodPtr),
      processIndex_(theId.processIndex()),
      productIndex_(theId.productIndex())
      {
        if(transient) {
          setTransient();
        }
        if(prodPtr==nullptr && prodGetter!=nullptr) {
          setCacheIsProductGetter(prodGetter);
        }
      }

edm::RefCore::RefCore

(

RefCore const &

iOther

)

Definition at line 47 of file RefCore.cc.

References cachePtr_.

                                         :
      processIndex_(iOther.processIndex_),
      productIndex_(iOther.productIndex_) {
       cachePtr_.store(iOther.cachePtr_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     }

edm::RefCore::RefCore ( RefCore &&  iOther )

inlinenoexcept

Definition at line 34 of file RefCore.h.

References cachePtr_.

                                         :
      processIndex_(iOther.processIndex_),
      productIndex_(iOther.productIndex_) {
         cachePtr_.store(iOther.cachePtr_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     }

edm::RefCore::~RefCore ( )

inlinenoexcept

Definition at line 47 of file RefCore.h.

{}

edm::RefCore::RefCore ( void const *  iCache, ProcessIndex  iProcessIndex, ProductIndex  iProductIndex  )

inlineprivate

Definition at line 115 of file RefCore.h.

References setId().

                                                                                       :
    cachePtr_(iCache), processIndex_(iProcessIndex), productIndex_(iProductIndex) {}

Member Function Documentation

bool edm::RefCore::cachePtrIsInvalid ( ) const

inlineprivate

Definition at line 121 of file RefCore.h.

References cachePtr_, and edm::refcoreimpl::kCacheIsProductPtrMask.

Referenced by getProductPtr(), pushBackItem(), and tryToGetProductPtr().

{ return 0 == (reinterpret_cast<std::uintptr_t>(cachePtr_.load()) & refcoreimpl::kCacheIsProductPtrMask); }

WrapperBase const * edm::RefCore::getProductPtr	(	std::type_info const &	type,
		EDProductGetter const *	prodGetter
	)		const

Definition at line 61 of file RefCore.cc.

References cachePtrIsInvalid(), edm::WrapperBase::dynamicTypeInfo(), edm::EDProductGetter::getIt(), id(), isTransient(), edm::ProductID::isValid(), productNotFoundException(), throwInvalidRefFromNoCache(), throwInvalidRefFromNullOrInvalidRef(), and wrongTypeException().

Referenced by edm::refcore::getProduct_(), edm::RefCoreWithIndex::getProductPtr(), edm::refcore::getProductWithCoreFromRef_(), and productGetter().

                                                                                          {
    // The following invariant would be nice to establish in all
    // constructors, but we can not be sure that the context in which
    // EDProductGetter::instance() is called will be one where a
    // non-null pointer is returned. The biggest question in the
    // various times at which Root makes RefCore instances, and how
    // old ones might be recycled.
    //
    // If our ProductID is non-null, we must have a way to get at the
    // product (unless it has been dropped). This means either we
    // already have the pointer to the product, or we have a valid
    // EDProductGetter to use.
    //
    //     assert(!id_.isValid() || productGetter() || prodPtr_);

    ProductID tId = id();
    assert (!isTransient());
    if (!tId.isValid()) {
      throwInvalidRefFromNullOrInvalidRef(TypeID(type));
    }

    //if (productPtr() == 0 && productGetter() == 0) {
    if (cachePtrIsInvalid()) {
      throwInvalidRefFromNoCache(TypeID(type),tId);
    }
    WrapperBase const* product = prodGetter->getIt(tId);
    if (product == nullptr) {
      productNotFoundException(type);
    }
    if(!(type == product->dynamicTypeInfo())) {
      wrongTypeException(type, product->dynamicTypeInfo());
    }
    return product;
  }

WrapperBase const * edm::RefCore::getThinnedProductPtr	(	std::type_info const &	type,
		unsigned int &	thinnedKey,
		EDProductGetter const *	prodGetter
	)		const

Definition at line 115 of file RefCore.cc.

References edm::WrapperBase::dynamicTypeInfo(), edm::EDProductGetter::getThinnedProduct(), id(), productNotFoundException(), and wrongTypeException().

Referenced by edm::refcore::getThinnedProduct_(), and productGetter().

                                                                                                                           {

    ProductID tId = id();
    WrapperBase const* product = prodGetter->getThinnedProduct(tId, thinnedKey);

    if (product == nullptr) {
      productNotFoundException(type);
    }
    if(!(type == product->dynamicTypeInfo())) {
      wrongTypeException(type, product->dynamicTypeInfo());
    }
    return product;
  }

ProductID edm::RefCore::id ( ) const

inline

Definition at line 49 of file RefCore.h.

References ID_IMPL.

Referenced by bitPackRefInfo(), edm::Ptr< reco::Muon >::getData_(), getProductPtr(), getThinnedProductPtr(), edm::PtrVectorBase::id(), edm::RefToBaseProd< T >::id(), edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::id(), edm::RefProd< Phase2TrackerCluster1Ds >::id(), edm::Ptr< reco::Muon >::id(), edm::Ref< L1GctEmCandCollection >::id(), edm::Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >::id(), isAvailable(), isThinnedAvailable(), edm::RefCoreStreamer::operator()(), edm::RefToBaseProd< T >::operator->(), edm::operator<(), edm::operator==(), productNotFoundException(), pushBackItem(), pushBackRefItem(), reco::TrackExtraBase::recHitRef(), tryToGetProductPtr(), and wrongTypeException().

{ID_IMPL;}

bool edm::RefCore::isAvailable

(

)

const

Definition at line 169 of file RefCore.cc.

References id(), edm::ProductID::isValid(), productGetter(), and productPtr().

Referenced by edm::PtrVectorBase::isAvailable(), edm::RefCoreWithIndex::isAvailable(), edm::RefVector< C, T, F >::isAvailable(), edm::RefProd< Phase2TrackerCluster1Ds >::isAvailable(), edm::Ref< C, T, F >::isAvailable(), edm::Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >::isAvailable(), and operator!().

                             {
    ProductID tId = id();
    //If another thread changes the cache, it will change a non-null productGetter
    // into a null productGeter but productPtr will be non-null
    // Therefore reading productGetter() first is the safe order
    auto prodGetter = productGetter();
    auto prodPtr = productPtr();
    return prodPtr != nullptr || (tId.isValid() && prodGetter != nullptr && prodGetter->getIt(tId) != nullptr);
  }

bool edm::RefCore::isNonnull ( ) const

inline

Definition at line 74 of file RefCore.h.

References ISNONNULL_IMPL.

Referenced by edm::PtrVectorBase::isNonnull(), edm::RefToBaseProd< T >::isNonnull(), edm::RefProd< Phase2TrackerCluster1Ds >::isNonnull(), isNull(), pushBackItem(), and pushBackRefItem().

{ISNONNULL_IMPL;}

bool edm::RefCore::isNull ( ) const

inline

Definition at line 71 of file RefCore.h.

References isNonnull().

Referenced by operator!(), edm::RefToBaseProd< T >::operator->(), pushBackItem(), and pushBackRefItem().

{return !isNonnull(); }

bool edm::RefCore::isThinnedAvailable	(	unsigned int	thinnedKey,
		EDProductGetter const *	prodGetter
	)		const

Definition at line 130 of file RefCore.cc.

References edm::EDProductGetter::getThinnedProduct(), id(), edm::ProductID::isValid(), and productPtr().

Referenced by edm::refitem::IsThinnedAvailableImpl< C, unsigned int >::isThinnedAvailable_(), and productGetter().

                                                                                              {
    ProductID tId = id();
    if(!tId.isValid() || prodGetter == nullptr) {
      //another thread may have changed it
      return nullptr != productPtr();
    }
    WrapperBase const* product = prodGetter->getThinnedProduct(tId, thinnedKey);
    return product != nullptr;
  }

bool edm::RefCore::isTransient ( ) const

inline

Definition at line 106 of file RefCore.h.

References ISTRANSIENT_IMPL.

Referenced by edm::getProduct(), edm::refcore::getProduct_(), getProductPtr(), edm::getProductWithCoreFromRef(), edm::getThinnedProduct(), edm::refitem::IsThinnedAvailableImpl< C, unsigned int >::isThinnedAvailable_(), edm::PtrVectorBase::isTransient(), edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::isTransient(), edm::RefProd< Phase2TrackerCluster1Ds >::isTransient(), edm::Ptr< reco::Muon >::isTransient(), edm::Ref< L1GctEmCandCollection >::isTransient(), edm::Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >::isTransient(), isTransientInt(), edm::RefCoreStreamer::operator()(), edm::operator<(), edm::operator==(), pushBackItem(), pushBackRefItem(), tryToGetProductPtr(), and edm::tryToGetProductWithCoreFromRef().

{ISTRANSIENT_IMPL;}

int edm::RefCore::isTransientInt ( ) const

inline

Definition at line 108 of file RefCore.h.

References isTransient(), pushBackItem(), and pushBackRefItem().

{return isTransient() ? 1 : 0;}

void edm::RefCore::nullPointerForTransientException

(

std::type_info const &

type

)

const

Definition at line 161 of file RefCore.cc.

References Exception, and edm::errors::InvalidReference.

Referenced by edm::getProduct(), edm::getProductWithCoreFromRef(), edm::getThinnedProduct(), edm::RefCoreWithIndex::nullPointerForTransientException(), productGetter(), and edm::tryToGetProductWithCoreFromRef().

                                                                          {
    throw edm::Exception(errors::InvalidReference)
    << "RefCore: A request to resolve a transient reference to a product of type: "
    << TypeID(type)
    << "\ncan not be satisfied because the pointer to the product is null.\n";
  }

bool edm::RefCore::operator! ( ) const

inline

Definition at line 77 of file RefCore.h.

References isAvailable(), and isNull().

{return isNull();}

RefCore & edm::RefCore::operator=

(

RefCore const &

iOther

)

Definition at line 53 of file RefCore.cc.

References cachePtr_, processIndex_, and productIndex_.

Referenced by RefCore().

                                                    {
    cachePtr_.store(iOther.cachePtr_.load(std::memory_order_relaxed), std::memory_order_relaxed);
    processIndex_ = iOther.processIndex_;
    productIndex_ = iOther.productIndex_;
    return *this;
  }

RefCore& edm::RefCore::operator= ( RefCore &&  iOther )

inlinenoexcept

Definition at line 40 of file RefCore.h.

References cachePtr_, processIndex_, and productIndex_.

                                                   {
      cachePtr_.store(iOther.cachePtr_.load(std::memory_order_relaxed), std::memory_order_relaxed);
      processIndex_ = iOther.processIndex_;
      productIndex_ = iOther.productIndex_;
      return *this;
    }

EDProductGetter const* edm::RefCore::productGetter ( ) const

inline

Definition at line 84 of file RefCore.h.

References getProductPtr(), getThinnedProductPtr(), isThinnedAvailable(), noexcept, nullPointerForTransientException(), PRODUCTGETTER_IMPL, productNotFoundException(), setProductGetter(), swap(), tryToGetProductPtr(), and wrongTypeException().

Referenced by edm::getProduct(), edm::refitem::GetRefPtrImpl< C, T, F, KEY >::getRefPtr_(), edm::refitem::GetRefPtrImpl< C, T, F, unsigned int >::getRefPtr_(), isAvailable(), edm::refitem::IsThinnedAvailableImpl< C, unsigned int >::isThinnedAvailable_(), edm::RefToBaseProd< T >::operator->(), edm::PtrVectorBase::productGetter(), edm::RefToBaseProd< T >::productGetter(), edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::productGetter(), edm::RefProd< Phase2TrackerCluster1Ds >::productGetter(), edm::Ptr< reco::Muon >::productGetter(), edm::Ref< L1GctEmCandCollection >::productGetter(), edm::Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >::productGetter(), pushBackItem(), and pushBackRefItem().

                                                 {
      PRODUCTGETTER_IMPL;
    }

void edm::RefCore::productNotFoundException

(

std::type_info const &

type

)

const

Definition at line 141 of file RefCore.cc.

References Exception, id(), and edm::errors::ProductNotFound.

Referenced by edm::Ptr< reco::Muon >::getData_(), getProductPtr(), getThinnedProductPtr(), productGetter(), and edm::RefCoreWithIndex::productNotFoundException().

                                                                  {
    throw edm::Exception(errors::ProductNotFound)
      << "RefCore: A request to resolve a reference to a product of type '"
      << TypeID(type)
      << "' with ProductID '" << id() << "'"
      << "\ncan not be satisfied because the product cannot be found."
      << "\nProbably the branch containing the product is not stored in the input file.\n";
  }

void const* edm::RefCore::productPtr ( ) const

inline

If productPtr is not 0 then productGetter will be 0 since only one is available at a time

Definition at line 52 of file RefCore.h.

References PRODUCTPTR_IMPL.

Referenced by edm::getProduct(), edm::refitem::GetRefPtrImpl< C, T, F, KEY >::getRefPtr_(), edm::refitem::GetRefPtrImpl< C, T, F, unsigned int >::getRefPtr_(), edm::RefToBaseProd< T >::hasCache(), edm::RefProd< Phase2TrackerCluster1Ds >::hasCache(), edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::hasProductCache(), edm::Ptr< reco::Muon >::hasProductCache(), edm::Ref< L1GctEmCandCollection >::hasProductCache(), edm::Ref< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value, typename refhelper::FindTrait< std::vector< E >, typename refhelper::ValueTrait< std::vector< E > >::value >::value >::hasProductCache(), isAvailable(), isThinnedAvailable(), edm::refitem::IsThinnedAvailableImpl< C, unsigned int >::isThinnedAvailable_(), edm::Ptr< T >::operator*(), edm::Ptr< T >::operator->(), edm::operator<(), edm::operator==(), edm::RefVectorBase< key_type >::pushBack(), pushBackItem(), reco::TrackExtraBase::recHitRef(), edm::RefToBaseProd< T >::RefToBaseProd(), reco::PFCandidate::storeRefInfo(), and edm::RefToBaseProd< T >::viewPtr().

{PRODUCTPTR_IMPL;}

void edm::RefCore::pushBackItem	(	RefCore const &	productToBeInserted,
		bool	checkPointer
	)

Definition at line 194 of file RefCore.cc.

References cachePtrIsInvalid(), Exception, id(), edm::errors::InvalidReference, isNonnull(), isNull(), isTransient(), productGetter(), productPtr(), setId(), setProductGetter(), setProductPtr(), and setTransient().

Referenced by isTransientInt(), edm::PtrVectorBase::push_back_base(), edm::RefCoreWithIndex::pushBackItem(), and reco::TrackExtraBase::setHits().

                                                                             {
    if (productToBeInserted.isNull() && !productToBeInserted.isTransient()) {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
    << "RefCore::pushBackItem: Ref or Ptr has invalid (zero) product ID, so it cannot be added to RefVector (PtrVector). "
    << "id should be (" << id() << ")\n";
    }
    if (isNonnull()) {
      if (isTransient() != productToBeInserted.isTransient()) {
        if (productToBeInserted.isTransient()) {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
        << "RefCore::pushBackItem: Transient Ref or Ptr cannot be added to persistable RefVector (PtrVector). "
        << "id should be (" << id() << ")\n";
        } else {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
        << "RefCore::pushBackItem: Persistable Ref or Ptr cannot be added to transient RefVector (PtrVector). "
        << "id is (" << productToBeInserted.id() << ")\n";
        }
      }
      if (!productToBeInserted.isTransient() && id() != productToBeInserted.id()) {
        throw edm::Exception(errors::InvalidReference,"Inconsistency")
      << "RefCore::pushBackItem: Ref or Ptr is inconsistent with RefVector (PtrVector)"
      << "id = (" << productToBeInserted.id() << ") should be (" << id() << ")\n";
      }
      if (productToBeInserted.isTransient() && checkPointer && productToBeInserted.isNonnull() && productToBeInserted != *this) {
        throw edm::Exception(errors::InvalidReference,"Inconsistency")
       << "RefCore::pushBackItem: Ref points into different collection than the RefVector.\n";
      }
    } else {
      if (productToBeInserted.isTransient()) {
        setTransient();
      }
      if (productToBeInserted.isNonnull()) {
        setId(productToBeInserted.id());
      }
    }
    //Since productPtr and productGetter actually share the same pointer internally,
    // we want to be sure that if the productPtr is set we use that one and only if
    // it isn't set do we set the productGetter if available
    if (productPtr() == nullptr && productToBeInserted.productPtr() != nullptr) {
      setProductPtr(productToBeInserted.productPtr());
    } else {
      auto getter = productToBeInserted.productGetter();
      if (cachePtrIsInvalid() && getter != nullptr) {
        setProductGetter(getter);
      }
    }
  }

void edm::RefCore::pushBackRefItem

(

RefCore const &

productToBeInserted

)

Definition at line 243 of file RefCore.cc.

References Exception, id(), edm::errors::InvalidReference, isNonnull(), isNull(), isTransient(), productGetter(), setId(), setProductGetter(), and setTransient().

Referenced by isTransientInt().

                                                             {
    if (productToBeInserted.isNull() && !productToBeInserted.isTransient()) {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
    << "RefCore::pushBackRefItem: Ref has invalid (zero) product ID, so it cannot be added to RefVector."
    << "id should be (" << id() << ")\n";
    }
    if (isNonnull() || isTransient()) {
      if (isTransient() != productToBeInserted.isTransient()) {
        if (productToBeInserted.isTransient()) {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
        << "RefCore::pushBackRefItem: Transient Ref cannot be added to persistable RefVector. "
        << "id should be (" << id() << ")\n";
        } else {
      throw edm::Exception(errors::InvalidReference,"Inconsistency")
        << "RefCore::pushBackRefItem: Persistable Ref cannot be added to transient RefVector. "
        << "id is (" << productToBeInserted.id() << ")\n";
        }
      }
      if (!productToBeInserted.isTransient() && id() != productToBeInserted.id()) {
        throw edm::Exception(errors::InvalidReference,"Inconsistency")
      << "RefCore::pushBackRefItem: Ref is inconsistent with RefVector"
      << "id = (" << productToBeInserted.id() << ") should be (" << id() << ")\n";
      }
    } else {
      if (productToBeInserted.isTransient()) {
        setTransient();
      }
      if (productToBeInserted.isNonnull()) {
        setId(productToBeInserted.id());
      }
    }
    auto prodGetter = productToBeInserted.productGetter();
    if (productGetter() == nullptr &&  prodGetter != nullptr) {
      setProductGetter(prodGetter);
    }
  }

void edm::RefCore::setCacheIsProductGetter ( EDProductGetter const *  iGetter ) const

inlineprivate

Definition at line 120 of file RefCore.h.

References SETCACHEISPRODUCTGETTER_IMPL.

Referenced by RefCore(), and setProductGetter().

{SETCACHEISPRODUCTGETTER_IMPL(iGetter);}

void edm::RefCore::setCacheIsProductPtr ( const void *  iItem ) const

inlineprivate

Definition at line 119 of file RefCore.h.

References SETCACHEISPRODUCTPTR_IMPL.

Referenced by setProductPtr().

{SETCACHEISPRODUCTPTR_IMPL(iItem);}

void edm::RefCore::setId ( ProductID const &  iId )

private

Definition at line 185 of file RefCore.cc.

References edm::refcoreimpl::kCacheIsProductPtrBit, edm::refcoreimpl::kTransientBit, edm::ProductID::processIndex(), processIndex_, edm::ProductID::productIndex(), and productIndex_.

Referenced by pushBackItem(), pushBackRefItem(), RefCore(), and edm::RefCoreWithIndex::setId().

                                     {
    unsigned short head = processIndex_ & (refcoreimpl::kTransientBit | refcoreimpl::kCacheIsProductPtrBit);
    processIndex_ = iId.processIndex();
    processIndex_ |= head;
    productIndex_ = iId.productIndex();
  }

void edm::RefCore::setProductGetter

(

EDProductGetter const *

prodGetter

)

const

Definition at line 180 of file RefCore.cc.

References setCacheIsProductGetter().

Referenced by productGetter(), pushBackItem(), pushBackRefItem(), edm::PtrVectorBase::setProductGetter(), and edm::RefCoreWithIndex::setProductGetter().

                                                                   {
    setCacheIsProductGetter(prodGetter);
  }

void edm::RefCore::setProductPtr ( void const *  prodPtr ) const

inline

This function is 'const' even though it changes an internal value becuase it is meant to be used as a way to store in a thread-safe way a cache of a value. This allows classes which use the RefCore to not have to declare it 'mutable'

Definition at line 58 of file RefCore.h.

References setCacheIsProductPtr().

Referenced by edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::at(), edm::refitem::findRefItem(), edm::Ptr< reco::Muon >::getData_(), edm::refcore::getProduct_(), edm::RefVector< std::vector< math::PtEtaPhiELorentzVectorD > >::operator[](), edm::Ptr< reco::Muon >::Ptr(), pushBackItem(), and edm::RefToBaseProd< T >::RefToBaseProd().

                                                  { 
      setCacheIsProductPtr(prodPtr);
    }

void edm::RefCore::setTransient ( )

inlineprivate

Definition at line 118 of file RefCore.h.

References SETTRANSIENT_IMPL.

Referenced by pushBackItem(), pushBackRefItem(), and RefCore().

{SETTRANSIENT_IMPL;}

void edm::RefCore::swap ( RefCore &  other )

inlinenoexcept

Definition at line 157 of file RefCore.h.

References cachePtr_, trackingPlots::other, processIndex_, productIndex_, and std::swap().

Referenced by productGetter(), edm::PtrVectorBase::swap(), and edm::swap().

                                        {
    std::swap(processIndex_, other.processIndex_);
    std::swap(productIndex_, other.productIndex_);
    other.cachePtr_.store(cachePtr_.exchange(other.cachePtr_.load()));
  }

WrapperBase const * edm::RefCore::tryToGetProductPtr	(	std::type_info const &	type,
		EDProductGetter const *	prodGetter
	)		const

Definition at line 97 of file RefCore.cc.

References cachePtrIsInvalid(), edm::WrapperBase::dynamicTypeInfo(), edm::EDProductGetter::getIt(), id(), isTransient(), edm::ProductID::isValid(), throwInvalidRefFromNoCache(), throwInvalidRefFromNullOrInvalidRef(), and wrongTypeException().

Referenced by productGetter(), and edm::refcore::tryToGetProductWithCoreFromRef_().

                                                                                               {
    ProductID tId = id();
    assert (!isTransient());
    if (!tId.isValid()) {
      throwInvalidRefFromNullOrInvalidRef(TypeID(type));
    }

    if (cachePtrIsInvalid()) {
      throwInvalidRefFromNoCache(TypeID(type),tId);
    }
    WrapperBase const* product = prodGetter->getIt(tId);
    if(product != nullptr && !(type == product->dynamicTypeInfo())) {
      wrongTypeException(type, product->dynamicTypeInfo());
    }
    return product;
  }

bool edm::RefCore::tryToSetProductPtrForFirstTime ( void const *  prodPtr ) const

inline

This function is 'const' even though it changes an internal value becuase it is meant to be used as a way to store in a thread-safe way a cache of a value. This allows classes which use the RefCore to not have to declare it 'mutable'

Definition at line 66 of file RefCore.h.

References cachePtr_, and edm::refcoreimpl::tryToSetCacheItemForFirstTime().

Referenced by edm::RefToBaseProd< T >::operator->().

                                                                   {
      return refcoreimpl::tryToSetCacheItemForFirstTime(cachePtr_, prodPtr);
    }

void edm::RefCore::wrongTypeException	(	std::type_info const &	expectedType,
		std::type_info const &	actualType
	)		const

Definition at line 151 of file RefCore.cc.

References Exception, id(), and edm::errors::InvalidReference.

Referenced by edm::refcore::getProduct_(), getProductPtr(), edm::refcore::getProductWithCoreFromRef_(), getThinnedProductPtr(), productGetter(), tryToGetProductPtr(), and edm::RefCoreWithIndex::wrongTypeException().

                                                                                                    {
    throw edm::Exception(errors::InvalidReference,"WrongType")
    << "RefCore: A request to convert a contained product of type '"
    << TypeID(actualType) << "'\n"
    << " to type '" << TypeID(expectedType) << "'"
    << "\nfor ProductID '" << id()
    << "' can not be satisfied\n";
  }

Friends And Related Function Documentation

friend class RefCoreWithIndex

friend

Definition at line 24 of file RefCore.h.

Member Data Documentation

std::atomic<void const*> edm::RefCore::cachePtr_

mutableprivate

Definition at line 126 of file RefCore.h.

Referenced by cachePtrIsInvalid(), operator=(), RefCore(), edm::RefCoreWithIndex::RefCoreWithIndex(), swap(), and tryToSetProductPtrForFirstTime().

ProcessIndex edm::RefCore::processIndex_

private

Definition at line 132 of file RefCore.h.

Referenced by operator=(), setId(), and swap().

ProductIndex edm::RefCore::productIndex_

private

Definition at line 133 of file RefCore.h.

Referenced by operator=(), setId(), and swap().