edm::productholderindexhelper Namespace Reference

Functions
TypeID	getContainedType (TypeID const &typeID)
TypeID	getContainedTypeFromWrapper (TypeID const &wrappedtypeID, std::string const &className)

Function Documentation

TypeID edm::productholderindexhelper::getContainedType

(

TypeID const &

typeID

)

Definition at line 52 of file ProductHolderIndexHelper.cc.

References edm::TypeWithDict::byName(), className(), edm::TypeID::className(), getContainedTypeFromWrapper(), AlCaHLTBitMon_QueryRunRegistry::string, edm::TypeWithDict::typeInfo(), and edm::wrappedClassName().

Referenced by edm::ProductHolderIndexHelper::insert().

                                           {
      std::string className = typeID.className();
      TypeWithDict const wrappedType = TypeWithDict::byName(wrappedClassName(className));
      TypeID const wrappedTypeID = TypeID(wrappedType.typeInfo());
      return getContainedTypeFromWrapper(wrappedTypeID, className);
    }

TypeID edm::productholderindexhelper::getContainedTypeFromWrapper	(	TypeID const &	wrappedtypeID,
		std::string const &	className
	)

Definition at line 20 of file ProductHolderIndexHelper.cc.

References GetRecoTauVFromDQM_MC_cff::cl, edm::TypeID::className(), unpackBuffers-CaloStage2::offset, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getContainedType(), and edm::ProductRegistry::initializeLookupTables().

                                                                                         {
      static int const vtcOffset = TClass::GetClass("edm::WrapperBase")->GetBaseClassOffset(TClass::GetClass("edm::ViewTypeChecker")); 
      static TClass const* const wbClass = TClass::GetClass("edm::WrapperBase");
      static std::string const refVector("edm::RefVector<");
      static std::string const refToBaseVector("edm::RefToBaseVector<");
      static std::string const ptrVector("edm::PtrVector<");
      static std::string const vectorPtr("std::vector<edm::Ptr<");
      static size_t const rvsize = refVector.size();
      static size_t const rtbvsize = refToBaseVector.size();
      static size_t const pvsize = ptrVector.size();
      static size_t const vpsize = vectorPtr.size();
      bool mayBeRefVector = (className.substr(0, rvsize) == refVector)
                         || (className.substr(0, rtbvsize) == refToBaseVector)
                         || (className.substr(0, pvsize) == ptrVector)
                         || (className.substr(0, vpsize) == vectorPtr);
      TClass* cl = TClass::GetClass(wrappedTypeID.className().c_str());
      if(cl == nullptr) {
        return TypeID(typeid(void));
      }
      void* p = cl->New();
      int offset = cl->GetBaseClassOffset(wbClass) + vtcOffset;;
      std::unique_ptr<ViewTypeChecker> checker = getAnyPtr<ViewTypeChecker>(p, offset);
      if(mayBeRefVector) {
        std::type_info const& ti = checker->memberTypeInfo(); 
        if(ti != typeid(void)) {
          return TypeID(ti);
        }
      }
      return TypeID(checker->valueTypeInfo());
    }