TScopeAdapter Class Reference

#include <RootType.h>

Collaboration diagram for TScopeAdapter:

Public Member Functions
	TScopeAdapter ()
	TScopeAdapter (TClass *klass)
	TScopeAdapter (const std::string &name, Bool_t load=kTRUE)
ATLAS_NOT_THREAD_SAFE	TScopeAdapter (const std::string &name, Bool_t load, Bool_t quiet)
	TScopeAdapter (const TMemberAdapter &)
	TScopeAdapter (const std::type_info &typeinfo)
	operator TClass * () const
	operator Bool_t () const
std::string	Name (unsigned int mod=Reflex::SCOPED) const
TScopeAdapter	DeclaringScope () const
void *	Construct () const
void *	Construct (void *place) const
void	Destruct (void *place) const
const std::type_info &	TypeInfo () const
TPropertyListAdapter	Properties () const
Bool_t	IsPointer () const
Bool_t	IsTemplateInstance () const
Bool_t	IsTopScope () const
Bool_t	IsFundamental () const
Bool_t	IsEnum () const
Bool_t	IsTypedef () const
Bool_t	IsArray () const
TBaseAdapter	BaseAt (size_t nth) const
size_t	BaseSize () const
size_t	SizeOf () const
TMemberAdapter	FunctionMemberAt (size_t nth) const
size_t	FunctionMemberSize () const
TMemberAdapter	DataMemberAt (size_t nth) const
size_t	DataMemberSize () const
TScopeAdapter	TemplateArgumentAt (size_t nth) const
size_t	TemplateArgumentSize () const
Bool_t	IsComplete () const
Bool_t	IsClass () const
Bool_t	IsStruct () const
Bool_t	IsNamespace () const
Bool_t	IsAbstract () const
void *	Id () const
TClass *	Class () const
TTypeAdapter	ToType () const
TScopeAdapter	TypeOf () const
bool	operator== (const TScopeAdapter &rh) const
bool	operator!= (const TScopeAdapter &rh) const
bool	operator< (const TScopeAdapter &rh) const

Static Public Member Functions
static TScopeAdapter ByName	ATLAS_NOT_THREAD_SAFE (const std::string &name, Bool_t load=kTRUE, Bool_t quiet=kTRUE)
static TScopeAdapter	ByNameNoQuiet (const std::string &name, Bool_t load=kTRUE)
static TScopeAdapter	TypeAt (size_t nth)
static size_t	TypeSize ()
static void	EnableCintex ()

Private Member Functions
void	Init (const std::string &name, Bool_t load, Bool_t quiet)

Private Attributes
std::string	fName
TClassRef	fClass
bool	fIsFundamental = false

Detailed Description

Definition at line 119 of file RootType.h.

Constructor & Destructor Documentation

TScopeAdapter() [1/6]

TScopeAdapter::TScopeAdapter

(

)

Definition at line 375 of file RootType.cxx.

{
   /* empty */
}

TScopeAdapter() [2/6]

TScopeAdapter::TScopeAdapter

(

TClass *

klass

)

Definition at line 380 of file RootType.cxx.

                                            : fClass( klass )
{
// wrap a class (scope)
   if ( fClass.GetClass() != 0 )
      fName = fClass->GetName();
}

TScopeAdapter() [3/6]

TScopeAdapter::TScopeAdapter	(	const std::string &	name,
		Bool_t	load = kTRUE )

Definition at line 498 of file RootType.cxx.

                                                                 :
      fName( name )
{
  Init (name, load, false);
}

TScopeAdapter() [4/6]

TScopeAdapter::TScopeAdapter	(	const std::string &	name,
		Bool_t	load,
		Bool_t	quiet )

Definition at line 506 of file RootType.cxx.

                                                                               :
      fName( name )
{
  Int_t oldEIL = gErrorIgnoreLevel;
  if( quiet )  gErrorIgnoreLevel = 3000;
  Init (name, load, quiet);
  gErrorIgnoreLevel = oldEIL;
}

TScopeAdapter() [5/6]

TScopeAdapter::TScopeAdapter

(

const TMemberAdapter &

mb

)

Definition at line 569 of file RootType.cxx.

                                                       :
      fName( mb.Name( Reflex::QUALIFIED | Reflex::SCOPED ) ),
      fClass( mb.Name( Reflex::SCOPED ).c_str() )
{
   /* empty */
}

TScopeAdapter() [6/6]

TScopeAdapter::TScopeAdapter

(

const std::type_info &

typeinfo

)

Definition at line 548 of file RootType.cxx.

  : fClass (TClassRef( TClass::GetClass(typeinfo) ) )   // MN: is that right?
{
   if( fClass.GetClass() ) {
      // We apparently see this sometimes due to races in TClass.
      // In that case, try retrieving it again.
      // (See ATEAM-697.)
      if (!fClass.GetClass()->HasDictionary()) {
        fClass = TClassRef( TClass::GetClass(typeinfo) );
      }
      fName = fClass->GetName();
   } else  {
      char buff[1024];
      size_t len = sizeof(buff);
      int    status = 0;
      fName = __cxxabiv1::__cxa_demangle(typeinfo.name(), buff, &len, &status);
      fIsFundamental = true;
   }
}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

TScopeAdapter ByName TScopeAdapter::ATLAS_NOT_THREAD_SAFE ( const std::string & name, Bool_t load = kTRUE, Bool_t quiet = kTRUE )

static

BaseAt()

TBaseAdapter TScopeAdapter::BaseAt

(

size_t

nth

)

const

Definition at line 776 of file RootType.cxx.

{
// get the nth base of this class
   return (TBaseClass*)fClass->GetListOfBases()->At( nth );
}

BaseSize()

size_t TScopeAdapter::BaseSize

(

)

const

Definition at line 752 of file RootType.cxx.

{
// get the total number of base classes that this class has
   if ( fClass.GetClass() && fClass->GetListOfBases() != 0 )
      return fClass->GetListOfBases()->GetSize();
 
   return 0;
}

ByNameNoQuiet()

TScopeAdapter TScopeAdapter::ByNameNoQuiet ( const std::string & name, Bool_t load = kTRUE )

static

Definition at line 584 of file RootType.cxx.

{
   return TScopeAdapter (name, load);
}

Class()

TClass * TScopeAdapter::Class ( ) const

inline

Definition at line 183 of file RootType.h.

{ return fClass.GetClass(); }

Construct() [1/2]

void * TScopeAdapter::Construct

(

)

const

Definition at line 664 of file RootType.cxx.

{
   return fClass.GetClass()? fClass.GetClass()->New() : 0;
}

Construct() [2/2]

void * RootType::Construct

(

void *

place

)

const

Definition at line 670 of file RootType.cxx.

                                           {
   return (place && fClass.GetClass())? fClass.GetClass()->New(place) : 0;
}

DataMemberAt()

TMemberAdapter TScopeAdapter::DataMemberAt

(

size_t

nth

)

const

Definition at line 810 of file RootType.cxx.

{
// get the nth data member of this class
   return (TDataMember*)fClass->GetListOfDataMembers()->At( nth );
}

DataMemberSize()

size_t TScopeAdapter::DataMemberSize

(

)

const

Definition at line 800 of file RootType.cxx.

{
// get the total number of data members that this class has
   if ( fClass.GetClass() )
      return fClass->GetListOfDataMembers()->GetSize();
 
   return 0;
}

DeclaringScope()

TScopeAdapter TScopeAdapter::DeclaringScope

(

)

const

Definition at line 653 of file RootType.cxx.

{
   std::string name = Name( Reflex::FINAL | Reflex::SCOPED );
   std::string::size_type pos = name.rfind( "::" );
   if ( pos == std::string::npos )
      return TScopeAdapter(  /* wrap global scope */
         TClass::GetClass( gInterpreter->ClassInfo_Factory( "" ) ) );
   return TScopeAdapter( name.substr( 0, pos ) );
}

Destruct()

void TScopeAdapter::Destruct

(

void *

place

)

const

Definition at line 675 of file RootType.cxx.

{
   if (place && fClass.GetClass()) fClass.GetClass()->Destructor(place);
}

EnableCintex()

void TScopeAdapter::EnableCintex ( )

inlinestatic

Definition at line 196 of file RootType.h.

{}

FunctionMemberAt()

TMemberAdapter TScopeAdapter::FunctionMemberAt

(

size_t

nth

)

const

Definition at line 793 of file RootType.cxx.

{
// get the nth method of this class
   return (TMethod*)fClass->GetListOfMethods()->At( nth );
}

FunctionMemberSize()

size_t TScopeAdapter::FunctionMemberSize

(

)

const

Definition at line 783 of file RootType.cxx.

{
// get the total number of methods that this class has
   if ( fClass.GetClass() )
      return fClass->GetListOfMethods()->GetSize();
 
   return 0;
}

Id()

void * TScopeAdapter::Id ( ) const

inline

Definition at line 182 of file RootType.h.

{ return fClass.GetClass(); }

Init()

void TScopeAdapter::Init ( const std::string & name, Bool_t load, Bool_t quiet )

private

Definition at line 517 of file RootType.cxx.

{
   const string anonnmsp("(anonymous)");
 
   if( !load ) {
      // let GetClass() have a crack at it first, to prevent accidental loading
      TClass* klass = TClass::GetClass( name.c_str(), load, quiet );
      if( klass ) {
         fClass = klass;
         return;
      }
   } else {
      // load
      const string scoped_name = Name( Reflex::SCOPED );
      fClass = TClassRef( scoped_name.c_str() );
      if( fClass.GetClass() ) {
         return;
      }
   }
   
   // now check if GetClass failed because of lack of dictionary or it is maybe not a class at all
   if( gROOT->GetType(name.c_str()) ) {
         fIsFundamental = true;
   } else if( TEnum::GetEnum(name.c_str(), load ? TEnum::kALoadAndInterpLookup :  TEnum::kNone) ) { 
      // MN: enum, or anonymous type that could be an enum.  for the moment mark it as fundamental
      fIsFundamental = true;
   }
}

IsAbstract()

Bool_t TScopeAdapter::IsAbstract

(

)

const

Definition at line 951 of file RootType.cxx.

{
// test if this scope represents an abstract class
   if ( fClass.GetClass() )
      return fClass->Property() & kIsAbstract;   // assume set only for classes
 
   return kFALSE;
}

IsArray()

Bool_t TScopeAdapter::IsArray

(

)

const

Definition at line 746 of file RootType.cxx.

{
   return fClass.GetClass()? fClass.GetClass()->Property() & kIsArray : false;
}

IsClass()

Bool_t TScopeAdapter::IsClass

(

)

const

Definition at line 913 of file RootType.cxx.

{
// test if this scope represents a class
   if ( fClass.GetClass() ) {
   // some inverted logic: we don't have a TClass, but a builtin will be recognized, so
   // if it is NOT a builtin, it is a class or struct (but may be missing dictionary)
      return (fClass->Property() & kIsClass) || ! (fClass->Property() & kIsFundamental);
   }
 
   // no class can mean either is no class (i.e. builtin), or no dict or interpreted(?)
   // as a workaround, use TDataTypes that has a full enumeration of builtin types
   return TDataType( Name( Reflex::FINAL | Reflex::SCOPED ).c_str() ).GetType() == kOther_t;
}

IsComplete()

Bool_t TScopeAdapter::IsComplete

(

)

const

Definition at line 892 of file RootType.cxx.

{
  // verify whether the dictionary of this class is fully available
   Bool_t b = kFALSE;
   std::string scname = Name( Reflex::SCOPED );
   TClass* klass = TClass::GetClass( scname.c_str(), true, true );
 
   if ( klass)  {// works for normal case w/ dict
      b = klass->HasDictionary();
   }
   else {       // special case for forward declared classes
      ClassInfo_t* ci = gInterpreter->ClassInfo_Factory( scname.c_str() );
      if ( ci ) {
         b = gInterpreter->ClassInfo_IsLoaded( ci );
         gInterpreter->ClassInfo_Delete( ci );    // we own the fresh class info
      }
   }
   return b;
}

IsEnum()

Bool_t TScopeAdapter::IsEnum

(

)

const

Definition at line 736 of file RootType.cxx.

{
   return fClass.GetClass()? fClass.GetClass()->Property() & kIsEnum : false;
}

IsFundamental()

Bool_t TScopeAdapter::IsFundamental

(

)

const

Definition at line 729 of file RootType.cxx.

{
   return fIsFundamental;
//   return fClass.GetClass()? fClass.GetClass()->Property() & kIsFundamental : false;
}

IsNamespace()

Bool_t TScopeAdapter::IsNamespace

(

)

const

Definition at line 941 of file RootType.cxx.

{
// test if this scope represents a namespace
   if ( fClass.GetClass() )
      return fClass->Property() & kIsNamespace;
 
   return kFALSE;
}

IsPointer()

Bool_t TScopeAdapter::IsPointer

(

)

const

Definition at line 700 of file RootType.cxx.

{
// the assumption here is that the adapter can be initialized with a sugared
// name, e.g. for function arguments
   return *fName.rbegin() == '*';
}

IsStruct()

Bool_t TScopeAdapter::IsStruct

(

)

const

Definition at line 928 of file RootType.cxx.

{
// test if this scope represents a struct
   if ( fClass.GetClass() ) {
   // same logic as for IsClass() above ...
      return (fClass->Property() & kIsStruct) || ! (fClass->Property() & kIsFundamental);
   }
 
// same logic as for IsClass() above ...
   return TDataType( Name( Reflex::FINAL | Reflex::SCOPED ).c_str() ).GetType() == kOther_t;
}

IsTemplateInstance()

Bool_t TScopeAdapter::IsTemplateInstance

(

)

const

Definition at line 708 of file RootType.cxx.

{
// this concept differs quite a bit between ROOT/meta and Reflex; this code
// supports both, with the addendum that the ROOT/meta idea of templates will
// not have template arguments
   if ( Name( Reflex::FINAL ).find('<') != std::string::npos )
      return kTRUE;          // Reflex notion of templates
 
   if ( gInterpreter->CheckClassTemplate( Name( Reflex::SCOPED ).c_str() ) )
      return kTRUE;
 
   return kFALSE;
}

IsTopScope()

Bool_t TScopeAdapter::IsTopScope

(

)

const

Definition at line 723 of file RootType.cxx.

{
// check whether this corresponds to the global scope
   return fClass->GetClassInfo() == gInterpreter->ClassInfo_Factory( "" );
}

IsTypedef()

Bool_t TScopeAdapter::IsTypedef

(

)

const

Definition at line 741 of file RootType.cxx.

{
   return fClass.GetClass()? fClass.GetClass()->Property() & kIsTypedef : false;
}

Name()

std::string TScopeAdapter::Name

(

unsigned int

mod = Reflex::SCOPED

)

const

Definition at line 610 of file RootType.cxx.

{
// Return name of type described by fClass
   if ( ! fClass.GetClass() || ! fClass->Property() ) {
   // fundamental types have no class, and unknown classes have no property
      std::string name = fName;
 
      if ( mod & Reflex::FINAL )
         name = ResolveTypedef( name );
 
      if ( ! ( mod & Reflex::QUALIFIED ) )
         name = UnqualifiedTypeName( fName );
 
      return name;
   }
 
   std::string name = fClass->GetName();
   if ( mod & Reflex::FINAL )
      name = ResolveTypedef( name );
 
   if ( ! (mod & Reflex::SCOPED) ) {
   // remove scope from the name
      Int_t tpl_open = 0;
      for ( std::string::size_type pos = name.size() - 1; 0 < pos; --pos ) {
         std::string::value_type c = name[ pos ];
 
      // count '<' and '>' to be able to skip template contents
         if ( c == '>' )
            ++tpl_open;
         else if ( c == '<' )
            --tpl_open;
         else if ( tpl_open == 0 && c == ':' && 0 < pos && name[ pos-1 ] == ':' ) {
         // found scope, strip name from it
            name = name.substr( pos+1, std::string::npos );
            break;
         }
      }
   }
 
   return name;
}

operator Bool_t()

TScopeAdapter::operator Bool_t

(

)

const

Definition at line 877 of file RootType.cxx.

{
   // check the validity of this scope (class)
   if( fName.empty() )      return false;
   if( fIsFundamental )     return true;
 
   // MN: rewriting this method to avoid premature header parsing
   TClass* klass = fClass.GetClass();
   if( !klass )  return false;
   if( klass->HasDictionary() )  return true;
 
   return false;
}

operator TClass *()

TScopeAdapter::operator TClass * ( ) const

inline

Definition at line 127 of file RootType.h.

{ return fClass.GetClass(); }

operator!=()

bool TScopeAdapter::operator!= ( const TScopeAdapter & rh ) const

inline

Definition at line 190 of file RootType.h.

                                                  {
      return ! (*this == rh);
   }

operator<()

bool TScopeAdapter::operator<

(

const TScopeAdapter &

rh

)

const

Definition at line 968 of file RootType.cxx.

{
// less-than operator, used for STL containers (makes little sense conceptually,
// but this class is used as a key in std::map<>s for some reason; choosing to
// compare on name here, as any simple comparison (e.g. GetClassInfo()) is bound
// to fall apart if classes are unloaded/updated/replaced).
   return Name( Reflex::FINAL | Reflex::SCOPED )
      < rh.Name( Reflex::FINAL | Reflex::SCOPED );
}

operator==()

bool TScopeAdapter::operator==

(

const TScopeAdapter &

rh

)

const

Definition at line 961 of file RootType.cxx.

{
// comparison operator, used for STL containers (implementation debatable)
   return fClass.GetClass() == rh.fClass.GetClass();
}

Properties()

TPropertyListAdapter TScopeAdapter::Properties

(

)

const

Definition at line 692 of file RootType.cxx.

{
// Reflex properties are more or less related to ROOT attributes: the names
// may be different (see map_property() above)
   return fIsFundamental? TPropertyListAdapter(0) : fClass->GetAttributeMap();
}

SizeOf()

size_t TScopeAdapter::SizeOf

(

)

const

Definition at line 763 of file RootType.cxx.

{
   if (fClass.GetClass()) {
      return fClass.GetClass()->Size();
   } else {
      const TDataType* fundType = gROOT->GetType(fName.c_str());
      if ( fundType )
         return fundType->Size();
   }
   return 0;
}

TemplateArgumentAt()

TScopeAdapter TScopeAdapter::TemplateArgumentAt

(

size_t

nth

)

const

Definition at line 817 of file RootType.cxx.

{
// this is stupid, but highly likely never called, and if it is, only once, so
// I don't see a reason for caching to prevent the extra loops
   std::string name = Name( Reflex::FINAL );
   size_t tpl_open = 0, argcount = 0;
   std::string::size_type last = 0;
   for ( std::string::size_type pos = 0; pos < name.size(); ++pos ) {
      std::string::value_type c = name[pos];
 
      // count '<' and '>' to be able to keep templated args intact
      if ( c == '<' ) {
         ++tpl_open;
         if (tpl_open == 1) last = pos+1;
         continue;
      } else if (c == '>' && tpl_open > 0) {
         --tpl_open;
      }
      if ((c == ',' && tpl_open == 1) || (c == '>' && tpl_open == 0)) {
         if ( argcount++ == nth ) {
            // Protect against data race inside TClassEdit.
            // https://github.com/root-project/root/issues/10353
            // Should be fixed in root 6.26.02.
            R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
            std::string part = 
               TClassEdit::CleanType( name.substr(last, pos-last).c_str(), 1 );
            return part;
         }
         last = pos+1;         // done with part
      }
   }
 
   // should never be called
   assert( !"miscount between TemplateArgumentSize() and TemplateArgumentAt()" );
   return TScopeAdapter();
}

TemplateArgumentSize()

size_t TScopeAdapter::TemplateArgumentSize

(

)

const

Definition at line 855 of file RootType.cxx.

{
// this is stupid, too, see TemplateArgumentAt() above
   std::string name = Name( Reflex::FINAL );
   size_t tpl_open = 0, argcount = 0;
   for ( std::string::size_type pos = 0; pos < name.size(); ++pos ) {
      std::string::value_type c = name[pos];
 
   // count '<' and '>' to be able to keep templated args intact
      if ( c == '<' ) {
          ++tpl_open;
          continue;
      } else if ( c == '>' && tpl_open > 0 )
          --tpl_open;
 
      if ((c == ',' && tpl_open == 1) || (c == '>' && tpl_open == 0))
         ++argcount;
   }
   return argcount;
}

ToType()

TTypeAdapter TScopeAdapter::ToType ( ) const

inline

Definition at line 185 of file RootType.h.

{ return *this; }

TypeAt()

TScopeAdapter TScopeAdapter::TypeAt ( size_t nth )

static

Definition at line 591 of file RootType.cxx.

{
   R__READ_LOCKGUARD (ROOT::gCoreMutex);
   const char *class_name = gClassTable->At( nth );
   // prevent autoloading, as it could change gClassTable 
   return class_name? TScopeAdapter( string(class_name), false ) : TScopeAdapter(); 
}

TypeInfo()

const type_info & TScopeAdapter::TypeInfo

(

)

const

Definition at line 682 of file RootType.cxx.

{
   if (fIsFundamental) { // Fundamentals have no fClass.GetClass()
      return fundamental_type(fName);
   }
   return  *fClass.GetClass()->GetTypeInfo();
}

TypeOf()

TScopeAdapter TScopeAdapter::TypeOf ( ) const

inline

Definition at line 186 of file RootType.h.

{ return *this; }

TypeSize()

size_t TScopeAdapter::TypeSize ( )

static

Definition at line 600 of file RootType.cxx.

{
// return total number of types in the system (this is stupid, as the number
// of types is dynamic ...)
  R__READ_LOCKGUARD (ROOT::gCoreMutex);
  TClassTable* tab ATLAS_THREAD_SAFE = gClassTable;
  return tab ? tab->Classes() : 0;
}

Member Data Documentation

fClass

TClassRef TScopeAdapter::fClass

private

Definition at line 202 of file RootType.h.

fIsFundamental

bool TScopeAdapter::fIsFundamental = false

private

Definition at line 203 of file RootType.h.

fName

std::string TScopeAdapter::fName

private

Definition at line 201 of file RootType.h.

---

The documentation for this class was generated from the following files:

• RootType.h
• RootType.cxx