edm::productholderindexhelper Namespace Reference

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

Function Documentation

getContainedType()

TypeID edm::productholderindexhelper::getContainedType

(

TypeID const &

typeID

)

Definition at line 67 of file ProductResolverIndexHelper.cc.

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

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

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

getContainedTypeFromWrapper()

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

Definition at line 19 of file ProductResolverIndexHelper.cc.

References haddnano::cl, className(), edm::TypeID::className(), hltrates_dqm_sourceclient-live_cfg::offset, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

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

                                                                                                {
      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 std::string const vectorUniquePtr("std::vector<std::unique_ptr<");
      static std::string const associationMap("edm::AssociationMap<");
      static std::string const newDetSetVector("edmNew::DetSetVector<");
      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();
      static size_t const vupsize = vectorUniquePtr.size();
      static size_t const amsize = associationMap.size();
      static size_t const ndsize = newDetSetVector.size();
      bool mayBeRefVector = (className.substr(0, rvsize) == refVector) ||
                            (className.substr(0, rtbvsize) == refToBaseVector) ||
                            (className.substr(0, pvsize) == ptrVector) || (className.substr(0, vpsize) == vectorPtr) ||
                            (className.substr(0, vupsize) == vectorUniquePtr);
      // AssociationMap and edmNew::DetSetVector do not support View and
      // this function is used to get a contained type that can be accessed
      // using a View. So return the void type in these cases.
      // In practice, they were the only types causing a problem, but any
      // type with a typedef named value_type that does not support
      // View might also cause problems and might need to be added here in
      // the future.
      if (className.substr(0, amsize) == associationMap || className.substr(0, ndsize) == newDetSetVector) {
        return TypeID(typeid(void));
      }
      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());
    }

typeIsViewCompatible()

bool edm::productholderindexhelper::typeIsViewCompatible	(	TypeID const &	requestedViewType,
		TypeID const &	wrappedtypeID,
		std::string const &	className
	)

Definition at line 74 of file ProductResolverIndexHelper.cc.

References newFWLiteAna::base, className(), getContainedTypeFromWrapper(), or, and edm::public_base_classes().

Referenced by edm::StreamSchedule::tryToPlaceConditionalModules().

                                                          {
      auto elementType = getContainedTypeFromWrapper(wrappedtypeID, className);
      if (elementType == TypeID(typeid(void)) or elementType == TypeID()) {
        //the wrapped type is not a container
        return false;
      }
      if (elementType == requestedViewType) {
        return true;
      }
      //need to check for inheritance match
      std::vector<std::string> missingDictionaries;
      std::vector<TypeWithDict> baseTypes;
      if (!public_base_classes(missingDictionaries, elementType, baseTypes)) {
        return false;
      }
      for (auto const& base : baseTypes) {
        if (TypeID(base.typeInfo()) == requestedViewType) {
          return true;
        }
      }
      return false;
    }