edm::TypeWithDict Class Reference

#include <TypeWithDict.h>

Public Member Functions
void *	allocate () const
size_t	arrayDimension () const
size_t	arrayLength () const
ObjectWithDict	construct () const
std::string	cppName () const
MemberWithDict	dataMemberByName (std::string const &) const
size_t	dataMemberSize () const
void	deallocate (void *address) const
void	destruct (void *address, bool dealloc=true) const
TypeWithDict	finalType () const
std::string	friendlyClassName () const
FunctionWithDict	functionMemberByName (std::string const &) const
FunctionWithDict	functionMemberByName (std::string const &name, std::string const &proto, bool isConst) const
size_t	functionMemberSize () const
int	getBaseClassOffset (TypeWithDict const &baseClass) const
TClass *	getClass () const
TDataType *	getDataType () const
TEnum *	getEnum () const
long	getProperty () const
bool	hasBase (std::string const &) const
bool	hasBase (TypeWithDict const &basety) const
bool	invalidTypeInfo () const
bool	isArray () const
bool	isClass () const
bool	isConst () const
bool	isEnum () const
bool	isFundamental () const
bool	isPointer () const
bool	isReference () const
bool	isTemplateInstance () const
bool	isTypedef () const
bool	isVirtual () const
size_t	maximumIndex (size_t dim) const
std::string	name () const
TypeWithDict	nestedType (char const *) const
TypeWithDict	nestedType (std::string const &) const
	operator bool () const
TypeWithDict &	operator= (TypeWithDict const &)
void const *	pointerToBaseType (void const *ptr, TypeWithDict const &derivedType) const
void const *	pointerToContainedType (void const *ptr, TypeWithDict const &derivedType) const
void	print (std::ostream &os) const
std::string	qualifiedName () const
size_t	size () const
int	stringToEnumValue (std::string const &) const
TypeWithDict &	stripConstRef ()
TypeWithDict	templateArgumentAt (size_t index) const
std::string	templateName () const
TypeWithDict	toType () const
std::type_info const &	typeInfo () const
	TypeWithDict ()
	TypeWithDict (TypeWithDict const &)
	TypeWithDict (TClass *type)
	TypeWithDict (TEnum *type)
	TypeWithDict (std::type_info const &)
	TypeWithDict (TMethodArg *arg)
std::string	unscopedName () const
std::type_info const &	unvalidatedTypeInfo () const
std::string	userClassName () const

Static Public Member Functions
static TypeWithDict	byName (std::string const &name)
static TypeWithDict	byTypeInfo (std::type_info const &ti)

Private Types
enum	dummyType
typedef dummyType **	invalidType

Private Member Functions
	TypeWithDict (std::type_info const &, long property)
	TypeWithDict (TClass *type, long property)
	TypeWithDict (TEnum *type, long property)
	TypeWithDict (TMethodArg *arg, long property)

Static Private Member Functions
static TypeWithDict	byName (std::string const &name, long property)

Private Attributes
value_ptr< std::vector< size_t > >	arrayDimensions_
TClass *	class_
TDataType *	dataType_
TEnum *	enum_
long	property_
std::type_info const *	ti_

Friends
bool	operator== (TypeWithDict const &, std::type_info const &)
class	TypeBases
class	TypeDataMembers
class	TypeFunctionMembers

Detailed Description

Definition at line 38 of file TypeWithDict.h.

Member Typedef Documentation

typedef dummyType** edm::TypeWithDict::invalidType

private

Definition at line 44 of file TypeWithDict.h.

Member Enumeration Documentation

enum edm::TypeWithDict::dummyType

private

Definition at line 43 of file TypeWithDict.h.

{} dummyType;        // Tag for valid type, but no type_info information

Constructor & Destructor Documentation

edm::TypeWithDict::TypeWithDict

(

)

Definition at line 238 of file TypeWithDict.cc.

Referenced by finalType(), templateArgumentAt(), and toType().

      : ti_(&typeid(TypeWithDict::invalidType)),
        class_(nullptr),
        enum_(nullptr),
        dataType_(nullptr),
        arrayDimensions_(nullptr),
        property_(0L) {}

edm::TypeWithDict::TypeWithDict

(

TypeWithDict const &

rhs

)

Definition at line 246 of file TypeWithDict.cc.

      : ti_(rhs.ti_),
        class_(rhs.class_),
        enum_(rhs.enum_),
        dataType_(rhs.dataType_),
        arrayDimensions_(rhs.arrayDimensions_),
        property_(rhs.property_) {}

edm::TypeWithDict::TypeWithDict ( TClass *  type )

explicit

Definition at line 316 of file TypeWithDict.cc.

: TypeWithDict(cl, 0L) {}

edm::TypeWithDict::TypeWithDict ( TEnum *  type )

explicit

Definition at line 330 of file TypeWithDict.cc.

: TypeWithDict(enm, 0L) {}

edm::TypeWithDict::TypeWithDict ( std::type_info const &  ti )

explicit

Definition at line 275 of file TypeWithDict.cc.

: TypeWithDict(ti, 0L) {}

edm::TypeWithDict::TypeWithDict ( TMethodArg *  arg )

explicit

Definition at line 340 of file TypeWithDict.cc.

: TypeWithDict(arg, 0L) {}

edm::TypeWithDict::TypeWithDict ( std::type_info const &  ti, long  property  )

explicitprivate

Definition at line 277 of file TypeWithDict.cc.

References byName(), class_, edm::TypeID::className(), dataType_, enum_, name(), and edm::throwTypeException().

      : ti_(&ti),
        class_(TClass::GetClass(ti)),
        enum_(nullptr),
        dataType_(TDataType::GetDataType(TDataType::GetType(ti))),
        arrayDimensions_(nullptr),
        property_(property) {
    if (class_ != nullptr) {
      return;
    }

    // Handle pointers and arrays
    // Must be done before dataType_ is checked, because dataType_ will be filled for char*
    char lastChar = TypeID(*ti_).className().back();
    if (lastChar == '*' || lastChar == ']') {
      *this = TypeWithDict::byName(TypeID(*ti_).className());
      return;
    }

    if (dataType_ != nullptr) {
      return;
    }

    enum_ = TEnum::GetEnum(ti, TEnum::kAutoload);
    if (enum_ != nullptr) {
      return;
    }

    if (ti == typeid(void)) {
      // For some reason, "void" has a data type if accessed by name, but not by type_info.
      dataType_ = gROOT->GetType("void");
      return;
    }

    // std::cerr << "DEBUG BY TI: " << name() << std::endl;

    throwTypeException("TypeWithDict): ", name());
  }

edm::TypeWithDict::TypeWithDict ( TClass *  type, long  property  )

explicitprivate

Definition at line 318 of file TypeWithDict.cc.

References ti_.

      : ti_(cl->GetTypeInfo()),
        class_(cl),
        enum_(nullptr),
        dataType_(nullptr),
        arrayDimensions_(nullptr),
        property_(property) {
    if (ti_ == nullptr) {
      ti_ = &typeid(TypeWithDict::dummyType);
    }
  }

edm::TypeWithDict::TypeWithDict ( TEnum *  type, long  property  )

explicitprivate

Definition at line 332 of file TypeWithDict.cc.

      : ti_(&typeid(TypeWithDict::dummyType)),
        class_(nullptr),
        enum_(enm),
        dataType_(nullptr),
        arrayDimensions_(nullptr),
        property_(property) {}

edm::TypeWithDict::TypeWithDict ( TMethodArg *  arg, long  property  )

explicitprivate

Definition at line 342 of file TypeWithDict.cc.

      : TypeWithDict(byName(arg->GetTypeName(), arg->Property() | property)) {}

Member Function Documentation

void * edm::TypeWithDict::allocate

(

)

const

Definition at line 787 of file TypeWithDict.cc.

References size().

Referenced by reco::parser::ExpressionVar::makeStorage(), and unvalidatedTypeInfo().

{ return new char[size()]; }

size_t edm::TypeWithDict::arrayDimension

(

)

const

Definition at line 518 of file TypeWithDict.cc.

References arrayDimensions_, and isArray().

Referenced by arrayLength(), name(), and unvalidatedTypeInfo().

                                            {
    assert(isArray());
    return arrayDimensions_->size();
  }

size_t edm::TypeWithDict::arrayLength

(

)

const

Definition at line 509 of file TypeWithDict.cc.

References arrayDimension(), mps_fire::i, isArray(), and maximumIndex().

Referenced by size(), and unvalidatedTypeInfo().

                                         {
    assert(isArray());
    size_t theLength = 1;
    for (size_t i = 0; i < arrayDimension(); ++i) {
      theLength *= maximumIndex(i);
    }
    return theLength;
  }

TypeWithDict edm::TypeWithDict::byName ( std::string const &  name )

static

Definition at line 74 of file TypeWithDict.cc.

References dttmaxenums::L.

Referenced by byName(), edm::checkClassDictionaries(), edm::ProductRegistry::checkDictionariesOfConsumedTypes(), edm::checkDictionary(), edm::checkDictionaryOfWrappedType(), BareRootProductGetter::createNewBuffer(), edm::FunctionWithDict::finalReturnType(), FWFileEntry::getBranchName(), fwlite::DataGetterHelper::getByBranchDescription(), edm::EventBase::getByLabel(), edm::productholderindexhelper::getContainedType(), edm::root::FWLiteDelayedReader::getTheProduct(), edm::BranchDescription::initFromDictionary(), edm::service::InitRootHandlers::InitRootHandlers(), edm::insertSelectedProcesses(), edm::loadCap(), FWParameterSetterBase::makeSetterFor(), reco::parser::ExpressionVar::makeStorage(), nestedType(), FWFileEntry::runFilter(), FWModelExpressionSelector::select(), FWModelFilter::setClassName(), FWExpressionEvaluator::setClassName(), edm::setIsMergeable(), edm::MergeableRunProductProcesses::setProcessesWithMergeableRunProducts(), FWTableViewManager::tableFormats(), templateArgumentAt(), edm::MemberWithDict::typeOf(), and TypeWithDict().

                                                         {
    // This is a public static function.
    auto const& item = typeMap.find(name);
    if (item != typeMap.end()) {
      return item->second;
    }
    TypeWithDict theType = TypeWithDict::byName(name, 0L);
    typeMap.insert(std::make_pair(name, theType));
    return theType;
  }

TypeWithDict edm::TypeWithDict::byName ( std::string const &  name, long  property  )

staticprivate

Definition at line 85 of file TypeWithDict.cc.

References arrayDimensions_, begin, diMuonSkim_cfi::byName, byName(), KineDebug3::count(), SiPixelPhase1DigisV_cfi::dimensions, end, edm::first(), dttmaxenums::L, property_, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and edm::stripNamespace().

                                                                        {
    // This is a private static function.

    static std::string const constPrefix("const ");
    static std::string const constSuffix(" const");
    static size_t const constPrefixSize(constPrefix.size());
    static size_t const constSuffixSize(constSuffix.size());

    // Handle references
    if (name.back() == '&') {
      assert(property == 0L);
      property |= kIsReference;
      return byName(name.substr(0, name.size() - 1), property);
    }

    // Handle const qualifier
    if (name.size() > constSuffixSize && name.back() != '*') {
      if (name.substr(0, constPrefixSize) == constPrefix) {
        property |= kIsConstant;
        return byName(name.substr(constPrefixSize), property);
      }
      if (name.substr(name.size() - constSuffixSize) == constSuffix) {
        property |= kIsConstant;
        return byName(name.substr(0, name.size() - constSuffixSize), property);
      }
    }

    // Handle pointers
    if (name.back() == '*') {
      // pointer to pointer not supported
      assert(!(property & (long)kIsPointer));
      // C-style array of pointers is not supported
      assert(!(property & (long)kIsArray));
      property |= kIsPointer;
      if (property & (long)kIsConstant) {
        property &= ~((long)kIsConstant);
        property |= kIsConstPointer;
      }
      return byName(name.substr(0, name.size() - 1), property);
    }

    // Handle C-style arrays
    if (name.back() == ']') {
      // pointer to array not supported
      assert(!(property & (long)kIsPointer));
      // Protect against the remote possibility of '[' nested in a class type
      size_t begin = name.find_last_of("<>:,()");
      if (begin == std::string::npos) {
        begin = 0;
      } else {
        ++begin;
      }
      size_t first = name.find('[', begin);
      assert(first != std::string::npos);
      assert(first != 0);
      TypeWithDict ret = TypeWithDict::byName(name.substr(0, first), property);
      ret.property_ |= kIsArray;
      ret.arrayDimensions_ = value_ptr<std::vector<size_t> >(new std::vector<size_t>);
      std::string const dimensions = name.substr(first);
      char const* s = dimensions.c_str();
      while (true) {
        size_t x = 0;
        int count = sscanf(s, "[%lu]", &x);
        assert(count == 1);
        ret.arrayDimensions_->push_back(x);
        ++s;
        while (*s != '\0' && *s != '[') {
          ++s;
        }
        if (*s == '\0') {
          break;
        }
      }
      return ret;
    }

    // Handle classes
    TClass* theClass = TClass::GetClass(name.c_str());
    if (theClass != nullptr) {
      return TypeWithDict(theClass, property);
    }

    // Handle enums
    TEnum* theEnum = TEnum::GetEnum(name.c_str(), TEnum::kAutoload);
    if (theEnum) {
      return TypeWithDict(theEnum, property);
    }

    // Handle built-ins
    TDataType* theDataType = gROOT->GetType(name.c_str());
    if (theDataType) {
      switch (theDataType->GetType()) {
        case kUInt_t:
          return TypeWithDict(typeid(unsigned int), property);
        case kInt_t:
          return TypeWithDict(typeid(int), property);
        case kULong_t:
          return TypeWithDict(typeid(unsigned long), property);
        case kLong_t:
          return TypeWithDict(typeid(long), property);
        case kULong64_t:
          return TypeWithDict(typeid(unsigned long long), property);
        case kLong64_t:
          return TypeWithDict(typeid(long long), property);
        case kUShort_t:
          return TypeWithDict(typeid(unsigned short), property);
        case kShort_t:
          return TypeWithDict(typeid(short), property);
        case kUChar_t:
          return TypeWithDict(typeid(unsigned char), property);
        case kChar_t:
          return TypeWithDict(typeid(char), property);
        case kBool_t:
          return TypeWithDict(typeid(bool), property);
        case kFloat_t:
          return TypeWithDict(typeid(float), property);
        case kFloat16_t:
          return TypeWithDict(typeid(Float16_t), property);
        case kDouble_t:
          return TypeWithDict(typeid(double), property);
        case kDouble32_t:
          return TypeWithDict(typeid(Double32_t), property);
        case kCharStar:
          return TypeWithDict(typeid(char*), property);
        case kDataTypeAliasSignedChar_t:
          return TypeWithDict(typeid(signed char), property);
      }
    }

    if (name == "void") {
      return TypeWithDict(typeid(void), property);
    }

    // For a reason not understood, TClass::GetClass sometimes cannot find std::type_info
    // by name.  This simple workaround bypasses the problem.
    // The problem really should be debugged.  (testORA12)
    if (name == "std::type_info") {
      return TypeWithDict(typeid(std::type_info), property);
    }

    // For a reason not understood, TClass::GetClass sometimes cannot find std::vector<T>::value_type
    // when T is a nested class.
    if (stripNamespace(name) == "value_type") {
      size_t begin = name.find('<');
      size_t end = name.rfind('>');
      if (begin != std::string::npos && end != std::string::npos && end > ++begin) {
        return TypeWithDict::byName(name.substr(begin, end - begin), property);
      }
    }
    //std::cerr << "DEBUG BY NAME: " << name << std::endl;
    return TypeWithDict();
  }

TypeWithDict edm::TypeWithDict::byTypeInfo ( std::type_info const &  ti )

static

Definition at line 62 of file TypeWithDict.cc.

References dttmaxenums::L.

Referenced by edm::ObjectWithDict::dynamicType().

                                                              {
    // This is a public static function.
    auto index = std::type_index(ti);
    auto const& item = typeIndexMap.find(index);
    if (item != typeIndexMap.end()) {
      return item->second;
    }
    TypeWithDict theType(ti, 0L);
    typeIndexMap.insert(std::make_pair(index, theType));
    return theType;
  }

ObjectWithDict edm::TypeWithDict::construct

(

)

const

Definition at line 791 of file TypeWithDict.cc.

References class_, isClass(), and size().

Referenced by edm::ObjectWithDict::byType(), and unvalidatedTypeInfo().

                                               {
    if (isClass()) {
      return ObjectWithDict(*this, class_->New());
    }
    return ObjectWithDict(*this, new char[size()]);
  }

std::string edm::TypeWithDict::cppName

(

)

const

Definition at line 433 of file TypeWithDict.cc.

References qualifiedName(), edm::replaceString(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by unvalidatedTypeInfo().

                                        {
    std::string cName = qualifiedName();
    // Get rid of silly ROOT typedefs
    replaceString(cName, "ULong64_t", "unsigned long long");
    replaceString(cName, "Long64_t", "long long");
    return cName;
  }

MemberWithDict edm::TypeWithDict::dataMemberByName

(

std::string const &

member

)

const

Definition at line 572 of file TypeWithDict.cc.

References haddnano::cl, class_, enum_, isClass(), and isEnum().

Referenced by reco::findDataMember(), edm::ObjectWithDict::get(), and unvalidatedTypeInfo().

                                                                             {
    if (isClass()) {
      TDataMember* dataMember = class_->GetDataMember(member.c_str());
      if (dataMember == nullptr) {
        // Look for indirect data members
        TRealData* realDataMember = class_->GetRealData(member.c_str());
        if (realDataMember != nullptr) {
          dataMember = realDataMember->GetDataMember();
        }
      }
      return MemberWithDict(dataMember);
    }
    if (isEnum()) {
      TClass* cl = enum_->GetClass();
      return MemberWithDict(cl->GetDataMember(member.c_str()));
    }
    return MemberWithDict();
  }

size_t edm::TypeWithDict::dataMemberSize

(

)

const

Definition at line 528 of file TypeWithDict.cc.

References class_, enum_, isClass(), and isEnum().

Referenced by reco::parser::AnyMethodArgumentFixup::operator()(), and unvalidatedTypeInfo().

                                            {
    if (isClass()) {
      return class_->GetListOfDataMembers()->GetSize();
    }
    if (isEnum()) {
      return enum_->GetConstants()->GetSize();
    }
    return 0;
  }

void edm::TypeWithDict::deallocate

(

void *

address

)

const

Definition at line 789 of file TypeWithDict.cc.

Referenced by reco::parser::ExpressionVar::delStorage(), and unvalidatedTypeInfo().

{ delete[] reinterpret_cast<char*>(address); }

void edm::TypeWithDict::destruct	(	void *	address,
		bool	dealloc = true
	)		const

Definition at line 798 of file TypeWithDict.cc.

References class_, and isClass().

Referenced by FWParameterSetterBase::makeSetterFor(), and unvalidatedTypeInfo().

                                                               {
    if (isClass()) {
      class_->Destructor(address, !dealloc);
      return;
    }
    if (dealloc) {
      delete[] reinterpret_cast<char*>(address);
    }
  }

TypeWithDict edm::TypeWithDict::finalType

(

)

const

Definition at line 623 of file TypeWithDict.cc.

References isClass(), isFundamental(), ti_, and TypeWithDict().

Referenced by reco::findMethod(), and unvalidatedTypeInfo().

                                             {
    if (*ti_ == typeid(invalidType)) {
      return TypeWithDict();
    }
    if (!isClass() && !isFundamental()) {
      return *this;
    }
    return TypeWithDict(*ti_);
  }

std::string edm::TypeWithDict::friendlyClassName

(

)

const

Definition at line 490 of file TypeWithDict.cc.

References edm::friendlyname::friendlyName(), and name().

Referenced by unvalidatedTypeInfo().

{ return friendlyname::friendlyName(name()); }

FunctionWithDict edm::TypeWithDict::functionMemberByName

(

std::string const &

member

)

const

Definition at line 591 of file TypeWithDict.cc.

References class_, isClass(), and TtSemiLepEvtBuilder_cfi::meth.

Referenced by reco::findMethod(), and unvalidatedTypeInfo().

                                                                                   {
    if (!isClass()) {
      return FunctionWithDict();
    }
    TMethod* meth = reinterpret_cast<TMethod*>(class_->GetListOfMethods()->FindObject(member.c_str()));
    if (meth == nullptr) {
      return FunctionWithDict();
    }
    return FunctionWithDict(meth);
  }

FunctionWithDict edm::TypeWithDict::functionMemberByName	(	std::string const &	name,
		std::string const &	proto,
		bool	isConst
	)		const

Definition at line 602 of file TypeWithDict.cc.

References class_, isClass(), isConst(), crabWrapper::key, TtSemiLepEvtBuilder_cfi::meth, name(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          {
    if (!isClass()) {
      return FunctionWithDict();
    }
    std::string const& key = name() + '#' + functionName + '#' + proto;
    auto const& item = functionMap.find(key);
    if (item != functionMap.end()) {
      return item->second;
    }
    TMethod* meth = class_->GetMethodWithPrototype(
        functionName.c_str(), proto.c_str(), /*objectIsConst=*/isConst, /*mode=*/ROOT::kConversionMatch);
    if (meth == nullptr) {
      return FunctionWithDict();
    }
    FunctionWithDict theFunction = FunctionWithDict(meth);
    functionMap.insert(std::make_pair(key, theFunction));
    return theFunction;
  }

size_t edm::TypeWithDict::functionMemberSize

(

)

const

Definition at line 538 of file TypeWithDict.cc.

References class_, and isClass().

Referenced by unvalidatedTypeInfo().

                                                {
    if (isClass()) {
      return class_->GetListOfMethods()->GetSize();
    }
    return 0;
  }

int edm::TypeWithDict::getBaseClassOffset

(

TypeWithDict const &

baseClass

)

const

Definition at line 761 of file TypeWithDict.cc.

References class_, Exception, isClass(), edm::errors::LogicError, name(), and PFRecoTauDiscriminationByIsolation_cfi::offset.

Referenced by edm::ObjectWithDict::castObject(), FWSimpleProxyHelper::itemChanged(), pointerToBaseType(), and unvalidatedTypeInfo().

                                                                          {
    if (!isClass()) {
      throw Exception(errors::LogicError) << "Function TypeWithDict::getBaseClassOffset(), type\n"
                                          << name() << "\nis not a class\n";
    }
    if (baseClass.class_ == nullptr) {
      throw Exception(errors::LogicError) << "Function TypeWithDict::getBaseClassOffset(), base type\n"
                                          << name() << "\nis not a class\n";
    }
    int offset = class_->GetBaseClassOffset(baseClass.class_);
    return offset;
  }

TClass * edm::TypeWithDict::getClass

(

)

const

Definition at line 380 of file TypeWithDict.cc.

References class_, isArray(), and isPointer().

Referenced by edm::checkClassDictionaries(), edm::ObjectWithDict::destruct(), edm::RootFile::dropOnInput(), FWSimpleRepresentationChecker::inheritsFrom(), edm::BranchDescription::initFromDictionary(), edm::insertSelectedProcesses(), edm::setIsMergeable(), edm::MergeableRunProductProcesses::setProcessesWithMergeableRunProducts(), and unvalidatedTypeInfo().

                                       {
    if (isPointer() || isArray()) {
      return nullptr;
    }
    return class_;
  }

TDataType * edm::TypeWithDict::getDataType

(

)

const

Definition at line 394 of file TypeWithDict.cc.

References dataType_, isArray(), and isPointer().

Referenced by unvalidatedTypeInfo().

                                             {
    if (isPointer() || isArray()) {
      return nullptr;
    }
    return dataType_;
  }

TEnum * edm::TypeWithDict::getEnum

(

)

const

Definition at line 387 of file TypeWithDict.cc.

References enum_, isArray(), and isPointer().

Referenced by unvalidatedTypeInfo().

                                     {
    if (isPointer() || isArray()) {
      return nullptr;
    }
    return enum_;
  }

long edm::TypeWithDict::getProperty

(

)

const

Definition at line 401 of file TypeWithDict.cc.

References property_.

Referenced by unvalidatedTypeInfo().

{ return property_; }

bool edm::TypeWithDict::hasBase

(

std::string const &

basename

)

const

Definition at line 736 of file TypeWithDict.cc.

References haddnano::cl, class_, and isClass().

Referenced by edm::ObjectWithDict::castObject(), and unvalidatedTypeInfo().

                                                            {
    if (!isClass()) {
      return false;
    }
    TClass* cl = class_->GetBaseClass(basename.c_str());
    if (cl != nullptr) {
      return true;
    }
    return false;
  }

bool edm::TypeWithDict::hasBase

(

TypeWithDict const &

basety

)

const

Definition at line 747 of file TypeWithDict.cc.

References haddnano::cl, class_, isClass(), and name().

                                                             {
    if (!isClass()) {
      return false;
    }
    if (basety.class_ == nullptr) {
      return false;
    }
    TClass* cl = class_->GetBaseClass(basety.name().c_str());
    if (cl != nullptr) {
      return true;
    }
    return false;
  }

bool edm::TypeWithDict::invalidTypeInfo

(

)

const

Definition at line 355 of file TypeWithDict.cc.

References isArray(), isPointer(), and ti_.

Referenced by edm::checkClassDictionaries(), and edm::checkDictionary().

{ return *ti_ == typeid(dummyType) || isPointer() || isArray(); }

bool edm::TypeWithDict::isArray

(

)

const

Definition at line 410 of file TypeWithDict.cc.

References property_.

Referenced by arrayDimension(), arrayLength(), getClass(), getDataType(), getEnum(), invalidTypeInfo(), isClass(), isEnum(), isFundamental(), maximumIndex(), name(), edm::operator==(), size(), toType(), typeInfo(), and unvalidatedTypeInfo().

{ return (property_ & (long)kIsArray); }

bool edm::TypeWithDict::isClass

(

)

const

Definition at line 403 of file TypeWithDict.cc.

References class_, isArray(), and isPointer().

Referenced by construct(), dataMemberByName(), dataMemberSize(), destruct(), finalType(), functionMemberByName(), functionMemberSize(), getBaseClassOffset(), hasBase(), reco::parser::LazyInvoker::invoke(), reco::parser::LazyInvoker::invokeLast(), isTemplateInstance(), isVirtual(), reco::parser::ExpressionVar::makeStorage(), name(), pointerToBaseType(), pointerToContainedType(), templateArgumentAt(), fireworks::OptionNode::typeHasOptions(), typeInfo(), and unvalidatedTypeInfo().

                                   {
    // Note: This really means is class, struct, or union.
    return class_ != nullptr && !isPointer() && !isArray();
  }

bool edm::TypeWithDict::isConst

(

)

const

Definition at line 408 of file TypeWithDict.cc.

References property_.

Referenced by functionMemberByName(), name(), qualifiedName(), and unvalidatedTypeInfo().

{ return (property_ & (long)kIsConstant); }

bool edm::TypeWithDict::isEnum

(

)

const

Definition at line 412 of file TypeWithDict.cc.

References enum_, isArray(), and isPointer().

Referenced by dataMemberByName(), dataMemberSize(), reco::parser::AnyMethodArgumentFixup::operator()(), stringToEnumValue(), reco::typeCode(), typeInfo(), and unvalidatedTypeInfo().

{ return enum_ != nullptr && !isPointer() && !isArray(); }

bool edm::TypeWithDict::isFundamental

(

)

const

Definition at line 414 of file TypeWithDict.cc.

References dataType_, isArray(), and isPointer().

Referenced by finalType(), and unvalidatedTypeInfo().

{ return dataType_ != nullptr && !isPointer() && !isArray(); }

bool edm::TypeWithDict::isPointer

(

)

const

Definition at line 416 of file TypeWithDict.cc.

References property_.

Referenced by reco::parser::ExpressionVar::delStorage(), fireworks::OptionNode::fillOptionForType(), reco::findDataMember(), reco::findMethod(), getClass(), getDataType(), getEnum(), invalidTypeInfo(), reco::parser::MethodInvoker::invoke(), isClass(), isEnum(), isFundamental(), reco::parser::ExpressionVar::makeStorage(), name(), edm::operator==(), qualifiedName(), size(), stripConstRef(), toType(), typeInfo(), and unvalidatedTypeInfo().

{ return (property_ & (long)kIsPointer); }

bool edm::TypeWithDict::isReference

(

)

const

Definition at line 418 of file TypeWithDict.cc.

References property_.

Referenced by reco::parser::ExpressionVar::delStorage(), reco::findMethod(), reco::parser::MethodInvoker::invoke(), reco::parser::ExpressionVar::makeStorage(), qualifiedName(), toType(), and unvalidatedTypeInfo().

{ return (property_ & (long)kIsReference); }

bool edm::TypeWithDict::isTemplateInstance

(

)

const

Definition at line 420 of file TypeWithDict.cc.

References isClass(), and name().

Referenced by reco::findMethod(), templateName(), and unvalidatedTypeInfo().

{ return (isClass() && name().back() == '>'); }

bool edm::TypeWithDict::isTypedef

(

)

const

Definition at line 422 of file TypeWithDict.cc.

References class_, dataType_, enum_, and ti_.

Referenced by reco::findMethod(), and unvalidatedTypeInfo().

                                     {
    if (class_ != nullptr || dataType_ != nullptr || enum_ != nullptr || *ti_ == typeid(invalidType)) {
      return false;
    }
    return true;
  }

bool edm::TypeWithDict::isVirtual

(

)

const

Definition at line 429 of file TypeWithDict.cc.

References class_, and isClass().

Referenced by edm::ObjectWithDict::dynamicType(), and unvalidatedTypeInfo().

{ return isClass() && (class_->ClassProperty() & (long)kClassHasVirtual); }

size_t edm::TypeWithDict::maximumIndex

(

size_t

dim

)

const

Definition at line 523 of file TypeWithDict.cc.

References arrayDimensions_, and isArray().

Referenced by arrayLength(), name(), and unvalidatedTypeInfo().

                                                    {
    assert(isArray());
    return (*arrayDimensions_)[dim];
  }

std::string edm::TypeWithDict::name

(

void

)

const

Definition at line 456 of file TypeWithDict.cc.

References arrayDimension(), class_, edm::TypeID::className(), TauDecayModes::dec, enum_, mps_fire::i, isArray(), isClass(), isConst(), isPointer(), maximumIndex(), MillePedeFileConverter_cfg::out, AlCaHLTBitMon_QueryRunRegistry::string, and ti_.

Referenced by config.CFG::__str__(), FWDetailView< reco::Muon >::classTypeName(), edm::convert_handle(), FWDetailViewManager::detailViewsFor(), validation.Sample::digest(), helper::Parser::elementType(), reco::findMethod(), friendlyClassName(), functionMemberByName(), FWItemValueGetter::FWItemValueGetter(), getBaseClassOffset(), fwlite::DataGetterHelper::getBranchDataFor(), FWFileEntry::getBranchName(), hasBase(), VIDSelectorBase.VIDSelectorBase::initialize(), isTemplateInstance(), FWParameterSetterBase::makeSetterFor(), nestedType(), FWDetailViewManager::openDetailViewFor(), reco::parser::AnyMethodArgumentFixup::operator()(), edm::operator<(), edm::operator==(), print(), edm::public_base_classes(), reco::parser::MethodSetter::push(), qualifiedName(), FWFileEntry::runFilter(), FWTableViewManager::tableFormats(), FWTableViewManager::tableFormatsImpl(), templateName(), reco::typeCode(), typeInfo(), TypeWithDict(), unscopedName(), unvalidatedTypeInfo(), fwlite::RecordWriter::update(), and userClassName().

                                     {
    if (*ti_ == typeid(invalidType)) {
      return std::string();
    }
    std::ostringstream out;
    if (isPointer() && isConst()) {
      out << "const ";
    }
    if (enum_ != nullptr) {
      if (enum_->GetClass()) {
        out << std::string(enum_->GetClass()->GetName());
        out << "::";
      }
      out << enum_->GetName();
    } else if (*ti_ == typeid(dummyType) && isClass()) {
      out << class_->GetName();
    } else {
      out << TypeID(*ti_).className();
    }
    if (isPointer()) {
      out << '*';
    }
    if (isArray()) {
      for (size_t i = 0; i < arrayDimension(); ++i) {
        out << '[';
        out << std::dec << maximumIndex(i);
        out << ']';
      }
    }
    return out.str();
  }

TypeWithDict edm::TypeWithDict::nestedType

(

char const *

nestedName

)

const

Definition at line 566 of file TypeWithDict.cc.

References byName(), and name().

Referenced by helper::Parser::elementType(), and unvalidatedTypeInfo().

{ return byName(name() + "::" + nestedName); }

TypeWithDict edm::TypeWithDict::nestedType

(

std::string const &

nestedName

)

const

Definition at line 568 of file TypeWithDict.cc.

References byName(), and name().

                                                                         {
    return byName(name() + "::" + nestedName);
  }

edm::TypeWithDict::operator bool ( ) const

explicit

Definition at line 345 of file TypeWithDict.cc.

References class_, dataType_, enum_, and ti_.

                                    {
    if (*ti_ == typeid(invalidType)) {
      return false;
    }
    if (class_ != nullptr || dataType_ != nullptr || enum_ != nullptr) {
      return true;
    }
    return false;
  }

TypeWithDict & edm::TypeWithDict::operator=

(

TypeWithDict const &

rhs

)

Definition at line 263 of file TypeWithDict.cc.

References arrayDimensions_, class_, dataType_, enum_, property_, and ti_.

                                                               {
    if (this != &rhs) {
      ti_ = rhs.ti_;
      class_ = rhs.class_;
      enum_ = rhs.enum_;
      dataType_ = rhs.dataType_;
      arrayDimensions_ = rhs.arrayDimensions_;
      property_ = rhs.property_;
    }
    return *this;
  }

void const * edm::TypeWithDict::pointerToBaseType	(	void const *	ptr,
		TypeWithDict const &	derivedType
	)		const

Definition at line 545 of file TypeWithDict.cc.

References getBaseClassOffset(), isClass(), PFRecoTauDiscriminationByIsolation_cfi::offset, and ti_.

Referenced by pointerToContainedType(), unvalidatedTypeInfo(), and fwlite::DataGetterHelper::wrapperBasePtr().

                                                                                                    {
    if (!isClass()) {
      return ptr;
    }
    if (this->ti_ == derivedType.ti_ || *this->ti_ == *derivedType.ti_) {
      return ptr;
    }
    int offset = derivedType.getBaseClassOffset(*this);
    if (offset < 0) {
      return nullptr;
    }
    return static_cast<char const*>(ptr) + offset;
  }

void const * edm::TypeWithDict::pointerToContainedType	(	void const *	ptr,
		TypeWithDict const &	derivedType
	)		const

Definition at line 559 of file TypeWithDict.cc.

References isClass(), and pointerToBaseType().

Referenced by unvalidatedTypeInfo().

                                                                                                         {
    if (!isClass()) {
      return ptr;
    }
    return pointerToBaseType(ptr, derivedType);
  }

void edm::TypeWithDict::print

(

std::ostream &

os

)

const

Definition at line 431 of file TypeWithDict.cc.

References name().

Referenced by edm::operator<<(), and unvalidatedTypeInfo().

{ os << name(); }

std::string edm::TypeWithDict::qualifiedName

(

)

const

Definition at line 441 of file TypeWithDict.cc.

References isConst(), isPointer(), isReference(), name(), property_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cppName(), reco::parser::MethodInvoker::invoke(), reco::parser::MethodInvoker::returnTypeName(), reco::parser::SingleInvoker::throwFailedConversion(), typeInfo(), and unvalidatedTypeInfo().

                                              {
    std::string qname(name());
    if (isConst() && !isPointer()) {
      qname = "const " + qname;
    } else if (property_ & kIsConstPointer) {
      qname += " const";
    }
    if (isReference()) {
      qname += '&';
    }
    return qname;
  }

size_t edm::TypeWithDict::size

(

void

)

const

Definition at line 492 of file TypeWithDict.cc.

References arrayLength(), class_, dataType_, enum_, createfilelist::int, isArray(), and isPointer().

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), allocate(), construct(), toType(), and unvalidatedTypeInfo().

                                  {
    size_t nBytes = 0;
    if (isPointer()) {
      nBytes = sizeof(void*);
    } else if (class_ != nullptr) {
      nBytes = class_->GetClassSize();
    } else if (dataType_ != nullptr) {
      nBytes = dataType_->Size();
    } else if (enum_ != nullptr) {
      nBytes = sizeof(int);
    }
    if (isArray()) {
      nBytes *= arrayLength();
    }
    return nBytes;
  }

int edm::TypeWithDict::stringToEnumValue

(

std::string const &

name

)

const

Definition at line 774 of file TypeWithDict.cc.

References RecoEcal_EventContent_cff::ec, enum_, Exception, isEnum(), and edm::errors::LogicError.

Referenced by reco::parser::AnyMethodArgumentFixup::operator()(), and unvalidatedTypeInfo().

                                                                 {
    if (!isEnum()) {
      throw Exception(errors::LogicError) << "Function TypeWithDict::stringToEnumValue(), type\n"
                                          << name << "\nis not an enum\n";
    }
    TEnumConstant const* ec = enum_->GetConstant(name.c_str());
    if (!ec) {
      throw Exception(errors::LogicError) << "Function TypeWithDict::stringToEnumValue(), type\n"
                                          << name << "\nis not an enum constant\n";
    }
    return static_cast<int>(ec->GetValue());
  }

TypeWithDict & edm::TypeWithDict::stripConstRef

(

)

Definition at line 254 of file TypeWithDict.cc.

References isPointer(), and property_.

Referenced by reco::findMethod(), and reco::parser::MethodInvoker::invoke().

                                            {
    if (isPointer()) {
      property_ &= ~((long)kIsReference | (long)kIsConstPointer);
    } else {
      property_ &= ~((long)kIsConstant | (long)kIsReference);
    }
    return *this;
  }

TypeWithDict edm::TypeWithDict::templateArgumentAt

(

size_t

index

)

const

Definition at line 697 of file TypeWithDict.cc.

References begin, byName(), EnergyCorrector::c, className(), egammaForCoreTracking_cff::depth, end, training_settings::idx, isClass(), AlCaHLTBitMon_QueryRunRegistry::string, TypeWithDict(), and unscopedName().

Referenced by helper::Parser::elementType(), and unvalidatedTypeInfo().

                                                                  {
    if (!isClass()) {
      return TypeWithDict();
    }
    std::string className(unscopedName());
    auto begin = className.find('<');
    if (begin == std::string::npos) {
      return TypeWithDict();
    }
    ++begin;
    auto end = className.rfind('>');
    assert(end != std::string::npos);
    assert(begin < end);
    int depth = 0;
    size_t argCount = 0;
    for (auto idx = begin; idx < end; ++idx) {
      char c = className[idx];
      if (c == '<') {
        ++depth;
      } else if (c == '>') {
        --depth;
        assert(depth >= 0);
      } else if ((depth == 0) && (c == ',')) {
        if (argCount < index) {
          begin = idx + 1;
          ++argCount;
        } else {
          end = idx;
          break;
        }
      }
    }
    assert(depth == 0);
    if (argCount < index) {
      return TypeWithDict();
    }
    return byName(className.substr(begin, end - begin));
  }

std::string edm::TypeWithDict::templateName

(

)

const

Definition at line 666 of file TypeWithDict.cc.

References begin, EnergyCorrector::c, egammaForCoreTracking_cff::depth, end, training_settings::idx, isTemplateInstance(), name(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reco::findMethod(), and unvalidatedTypeInfo().

                                             {
    if (!isTemplateInstance()) {
      return "";
    }
    if (name() == "std::string") {
      return std::string("std::basic_string");
    }
    std::string templateName(name());
    auto begin = templateName.find('<');
    assert(begin != std::string::npos);
    auto end = templateName.rfind('<');
    assert(end != std::string::npos);
    assert(begin <= end);
    if (begin < end) {
      int depth = 1;
      for (auto idx = begin + 1; idx <= end; ++idx) {
        char c = templateName[idx];
        if (c == '<') {
          if (depth == 0) {
            begin = idx;
          }
          ++depth;
        } else if (c == '>') {
          --depth;
          assert(depth >= 0);
        }
      }
    }
    return templateName.substr(0, begin);
  }

TypeWithDict edm::TypeWithDict::toType

(

)

const

Definition at line 633 of file TypeWithDict.cc.

References arrayDimensions_, mps_fire::i, isArray(), isPointer(), isReference(), property_, size(), ti_, and TypeWithDict().

Referenced by fireworks::OptionNode::fillOptionForType(), reco::findDataMember(), reco::findMethod(), reco::parser::MethodInvoker::invoke(), and unvalidatedTypeInfo().

                                          {
    if (*ti_ == typeid(invalidType)) {
      return TypeWithDict();
    }
    if (isReference()) {
      TypeWithDict newType = *this;
      newType.property_ &= ~((long)kIsReference);
      return newType;
    }
    if (isPointer()) {
      TypeWithDict newType = *this;
      newType.property_ &= ~((long)kIsPointer | (long)kIsConstPointer);
      return newType;
    }
    if (isArray()) {
      TypeWithDict newType = *this;
      size_t size = newType.arrayDimensions_->size();
      if (size == 1) {
        newType.property_ &= ~((long)kIsArray);
        value_ptr<std::vector<size_t> > emptyVec;
        newType.arrayDimensions_ = emptyVec;
      } else {
        std::vector<size_t>& dims = *newType.arrayDimensions_;
        for (size_t i = 0; i != size; ++i) {
          dims[i] = dims[i + 1];
        }
        newType.arrayDimensions_->resize(size - 1);
      }
      return newType;
    }
    return *this;
  }

std::type_info const & edm::TypeWithDict::typeInfo

(

)

const

Definition at line 357 of file TypeWithDict.cc.

References taus_updatedMVAIds_cff::category, edm::errors::DictionaryNotFound, Exception, isArray(), isClass(), isEnum(), isPointer(), edm::errors::LogicError, name(), qualifiedName(), AlCaHLTBitMon_QueryRunRegistry::string, and ti_.

Referenced by edm::ObjectWithDict::castObject(), FWFileEntry::getBranchName(), edm::EventBase::getByLabel(), edm::productholderindexhelper::getContainedType(), FWSimpleRepresentationChecker::inheritsFrom(), reco::parser::LazyInvoker::invoker(), edm::public_base_classes(), edm::ThinningProducer< Collection, Selector >::registerThinnedAssociations(), FWFileEntry::runFilter(), edm::BranchDescription::setSwitchAliasForBranch(), edm::BranchDescription::unwrappedTypeID(), and edm::BranchDescription::wrappedTypeID().

                                                   {
    if (*ti_ == typeid(dummyType) || isPointer() || isArray()) {
      // No accurate type_info
      if (qualifiedName().c_str() != nullptr) {
        std::string category("unknown");
        if (isPointer()) {
          category = "a pointer";
        } else if (isArray()) {
          category = "an array";
        } else if (isEnum()) {
          category = "an enum";
        } else if (isClass()) {
          throw Exception(errors::DictionaryNotFound) << "No Dictionary for class: '" << name() << "'" << std::endl;
        }
        throw Exception(errors::LogicError)
            << "Function TypeWithDict::typeInfo: Type\n"
            << qualifiedName() << "\ndoes not have valid type_info information in ROOT\n"
            << "because it is " << category << ".\n";
      }
    }
    return *ti_;
  }

std::string edm::TypeWithDict::unscopedName

(

)

const

Definition at line 454 of file TypeWithDict.cc.

References name(), and edm::stripNamespace().

Referenced by templateArgumentAt(), and unvalidatedTypeInfo().

{ return stripNamespace(name()); }

std::type_info const& edm::TypeWithDict::unvalidatedTypeInfo ( ) const

inline

Definition at line 81 of file TypeWithDict.h.

References allocate(), arrayDimension(), arrayLength(), construct(), cppName(), dataMemberByName(), dataMemberSize(), deallocate(), destruct(), finalType(), friendlyClassName(), functionMemberByName(), functionMemberSize(), getBaseClassOffset(), getClass(), getDataType(), getEnum(), getProperty(), hasBase(), edm::hasDictionary(), isArray(), isClass(), isConst(), isEnum(), isFundamental(), isPointer(), isReference(), isTemplateInstance(), isTypedef(), isVirtual(), maximumIndex(), name(), nestedType(), pointerToBaseType(), pointerToContainedType(), print(), qualifiedName(), size(), AlCaHLTBitMon_QueryRunRegistry::string, stringToEnumValue(), templateArgumentAt(), templateName(), ti_, toType(), unscopedName(), and userClassName().

Referenced by edm::DataManagingProductResolver::checkType().

{ return *ti_; }

std::string edm::TypeWithDict::userClassName

(

)

const

Definition at line 488 of file TypeWithDict.cc.

References name().

Referenced by unvalidatedTypeInfo().

{ return name(); }

Friends And Related Function Documentation

bool operator== ( TypeWithDict const &  a, std::type_info const &  b  )

friend

Definition at line 819 of file TypeWithDict.cc.

Referenced by edm::operator!=(), and edm::operator<().

                                                                {
    if (*a.ti_ == typeid(TypeWithDict::dummyType) || a.isPointer() || a.isArray()) {
      // No accurate type_info
      return a.name() == TypeID(b).className();
    }
    return *a.ti_ == b;
  }

friend class TypeBases

friend

Definition at line 39 of file TypeWithDict.h.

friend class TypeDataMembers

friend

Definition at line 40 of file TypeWithDict.h.

friend class TypeFunctionMembers

friend

Definition at line 41 of file TypeWithDict.h.

Member Data Documentation

value_ptr<std::vector<size_t> > edm::TypeWithDict::arrayDimensions_

private

Definition at line 50 of file TypeWithDict.h.

Referenced by arrayDimension(), byName(), maximumIndex(), operator=(), and toType().

TClass* edm::TypeWithDict::class_

private

Definition at line 47 of file TypeWithDict.h.

Referenced by construct(), dataMemberByName(), dataMemberSize(), destruct(), functionMemberByName(), functionMemberSize(), getBaseClassOffset(), getClass(), hasBase(), isClass(), isTypedef(), isVirtual(), name(), operator bool(), operator=(), size(), and TypeWithDict().

TDataType* edm::TypeWithDict::dataType_

private

Definition at line 49 of file TypeWithDict.h.

Referenced by getDataType(), isFundamental(), isTypedef(), operator bool(), operator=(), size(), and TypeWithDict().

TEnum* edm::TypeWithDict::enum_

private

Definition at line 48 of file TypeWithDict.h.

Referenced by dataMemberByName(), dataMemberSize(), getEnum(), isEnum(), isTypedef(), name(), operator bool(), operator=(), size(), stringToEnumValue(), and TypeWithDict().

long edm::TypeWithDict::property_

private

Definition at line 51 of file TypeWithDict.h.

Referenced by byName(), getProperty(), isArray(), isConst(), isPointer(), isReference(), operator=(), qualifiedName(), stripConstRef(), and toType().

std::type_info const* edm::TypeWithDict::ti_

private

Definition at line 46 of file TypeWithDict.h.

Referenced by finalType(), invalidTypeInfo(), isTypedef(), name(), operator bool(), operator=(), edm::operator==(), pointerToBaseType(), toType(), typeInfo(), TypeWithDict(), and unvalidatedTypeInfo().