ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | List of all members
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 372 of file RootType.cxx.

373 {
374  /* empty */
375 }

◆ TScopeAdapter() [2/6]

TScopeAdapter::TScopeAdapter ( TClass *  klass)

Definition at line 377 of file RootType.cxx.

377  : fClass( klass )
378 {
379 // wrap a class (scope)
380  if ( fClass.GetClass() != 0 )
381  fName = fClass->GetName();
382 }

◆ TScopeAdapter() [3/6]

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

Definition at line 495 of file RootType.cxx.

495  :
496  fName( name )
497 {
498  Init (name, load, false);
499 }

◆ TScopeAdapter() [4/6]

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

Definition at line 503 of file RootType.cxx.

503  :
504  fName( name )
505 {
506  Int_t oldEIL = gErrorIgnoreLevel;
507  if( quiet ) gErrorIgnoreLevel = 3000;
508  Init (name, load, quiet);
509  gErrorIgnoreLevel = oldEIL;
510 }

◆ TScopeAdapter() [5/6]

TScopeAdapter::TScopeAdapter ( const TMemberAdapter mb)

Definition at line 566 of file RootType.cxx.

566  :
568  fClass( mb.Name( Reflex::SCOPED ).c_str() )
569 {
570  /* empty */
571 }

◆ TScopeAdapter() [6/6]

TScopeAdapter::TScopeAdapter ( const std::type_info &  typeinfo)

Definition at line 545 of file RootType.cxx.

546  : fClass (TClassRef( TClass::GetClass(typeinfo) ) ) // MN: is that right?
547 {
548  if( fClass.GetClass() ) {
549  // We apparently see this sometimes due to races in TClass.
550  // In that case, try retrieving it again.
551  // (See ATEAM-697.)
552  if (!fClass.GetClass()->HasDictionary()) {
553  fClass = TClassRef( TClass::GetClass(typeinfo) );
554  }
555  fName = fClass->GetName();
556  } else {
557  char buff[1024];
558  size_t len = sizeof(buff);
559  int status = 0;
560  fName = __cxxabiv1::__cxa_demangle(typeinfo.name(), buff, &len, &status);
561  fIsFundamental = true;
562  }
563 }

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

static 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 773 of file RootType.cxx.

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

◆ BaseSize()

size_t TScopeAdapter::BaseSize ( ) const

Definition at line 749 of file RootType.cxx.

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

◆ ByNameNoQuiet()

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

Definition at line 581 of file RootType.cxx.

583 {
584  return TScopeAdapter (name, load);
585 }

◆ Class()

TClass* TScopeAdapter::Class ( ) const
inline

Definition at line 183 of file RootType.h.

183 { return fClass.GetClass(); }

◆ Construct() [1/2]

void * TScopeAdapter::Construct ( ) const

Definition at line 661 of file RootType.cxx.

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

◆ Construct() [2/2]

void * RootType::Construct ( void *  place) const

Definition at line 667 of file RootType.cxx.

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

◆ DataMemberAt()

TMemberAdapter TScopeAdapter::DataMemberAt ( size_t  nth) const

Definition at line 807 of file RootType.cxx.

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

◆ DataMemberSize()

size_t TScopeAdapter::DataMemberSize ( ) const

Definition at line 797 of file RootType.cxx.

798 {
799 // get the total number of data members that this class has
800  if ( fClass.GetClass() )
801  return fClass->GetListOfDataMembers()->GetSize();
802 
803  return 0;
804 }

◆ DeclaringScope()

TScopeAdapter TScopeAdapter::DeclaringScope ( ) const

Definition at line 650 of file RootType.cxx.

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

◆ Destruct()

void TScopeAdapter::Destruct ( void *  place) const

Definition at line 672 of file RootType.cxx.

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

◆ EnableCintex()

static void TScopeAdapter::EnableCintex ( )
inlinestatic

Definition at line 196 of file RootType.h.

196 {}

◆ FunctionMemberAt()

TMemberAdapter TScopeAdapter::FunctionMemberAt ( size_t  nth) const

Definition at line 790 of file RootType.cxx.

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

◆ FunctionMemberSize()

size_t TScopeAdapter::FunctionMemberSize ( ) const

Definition at line 780 of file RootType.cxx.

781 {
782 // get the total number of methods that this class has
783  if ( fClass.GetClass() )
784  return fClass->GetListOfMethods()->GetSize();
785 
786  return 0;
787 }

◆ Id()

void* TScopeAdapter::Id ( ) const
inline

Definition at line 182 of file RootType.h.

182 { return fClass.GetClass(); }

◆ Init()

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

Definition at line 514 of file RootType.cxx.

515 {
516  const string anonnmsp("(anonymous)");
517 
518  if( !load ) {
519  // let GetClass() have a crack at it first, to prevent accidental loading
520  TClass* klass = TClass::GetClass( name.c_str(), load, quiet );
521  if( klass ) {
522  fClass = klass;
523  return;
524  }
525  } else {
526  // load
527  const string scoped_name = Name( Reflex::SCOPED );
528  fClass = TClassRef( scoped_name.c_str() );
529  if( fClass.GetClass() ) {
530  return;
531  }
532  }
533 
534  // now check if GetClass failed because of lack of dictionary or it is maybe not a class at all
535  if( gROOT->GetType(name.c_str()) ) {
536  fIsFundamental = true;
537  } else if( TEnum::GetEnum(name.c_str(), load ? TEnum::kALoadAndInterpLookup : TEnum::kNone) ) {
538  // MN: enum, or anonymous type that could be an enum. for the moment mark it as fundamental
539  fIsFundamental = true;
540  }
541 }

◆ IsAbstract()

Bool_t TScopeAdapter::IsAbstract ( ) const

Definition at line 949 of file RootType.cxx.

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

◆ IsArray()

Bool_t TScopeAdapter::IsArray ( ) const

Definition at line 743 of file RootType.cxx.

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

◆ IsClass()

Bool_t TScopeAdapter::IsClass ( ) const

Definition at line 911 of file RootType.cxx.

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

◆ IsComplete()

Bool_t TScopeAdapter::IsComplete ( ) const

Definition at line 890 of file RootType.cxx.

891 {
892  // verify whether the dictionary of this class is fully available
893  Bool_t b = kFALSE;
894  std::string scname = Name( Reflex::SCOPED );
895  TClass* klass = TClass::GetClass( scname.c_str(), true, true );
896 
897  if ( klass) {// works for normal case w/ dict
898  b = klass->HasDictionary();
899  }
900  else { // special case for forward declared classes
901  ClassInfo_t* ci = gInterpreter->ClassInfo_Factory( scname.c_str() );
902  if ( ci ) {
903  b = gInterpreter->ClassInfo_IsLoaded( ci );
904  gInterpreter->ClassInfo_Delete( ci ); // we own the fresh class info
905  }
906  }
907  return b;
908 }

◆ IsEnum()

Bool_t TScopeAdapter::IsEnum ( ) const

Definition at line 733 of file RootType.cxx.

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

◆ IsFundamental()

Bool_t TScopeAdapter::IsFundamental ( ) const

Definition at line 726 of file RootType.cxx.

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

◆ IsNamespace()

Bool_t TScopeAdapter::IsNamespace ( ) const

Definition at line 939 of file RootType.cxx.

940 {
941 // test if this scope represents a namespace
942  if ( fClass.GetClass() )
943  return fClass->Property() & kIsNamespace;
944 
945  return kFALSE;
946 }

◆ IsPointer()

Bool_t TScopeAdapter::IsPointer ( ) const

Definition at line 697 of file RootType.cxx.

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

◆ IsStruct()

Bool_t TScopeAdapter::IsStruct ( ) const

Definition at line 926 of file RootType.cxx.

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

◆ IsTemplateInstance()

Bool_t TScopeAdapter::IsTemplateInstance ( ) const

Definition at line 705 of file RootType.cxx.

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

◆ IsTopScope()

Bool_t TScopeAdapter::IsTopScope ( ) const

Definition at line 720 of file RootType.cxx.

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

◆ IsTypedef()

Bool_t TScopeAdapter::IsTypedef ( ) const

Definition at line 738 of file RootType.cxx.

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

◆ Name()

std::string TScopeAdapter::Name ( unsigned int  mod = Reflex::SCOPED) const

Definition at line 607 of file RootType.cxx.

608 {
609 // Return name of type described by fClass
610  if ( ! fClass.GetClass() || ! fClass->Property() ) {
611  // fundamental types have no class, and unknown classes have no property
612  std::string name = fName;
613 
614  if ( mod & Reflex::FINAL )
615  name = ResolveTypedef( name );
616 
617  if ( ! ( mod & Reflex::QUALIFIED ) )
618  name = UnqualifiedTypeName( fName );
619 
620  return name;
621  }
622 
623  std::string name = fClass->GetName();
624  if ( mod & Reflex::FINAL )
625  name = ResolveTypedef( name );
626 
627  if ( ! (mod & Reflex::SCOPED) ) {
628  // remove scope from the name
629  Int_t tpl_open = 0;
630  for ( std::string::size_type pos = name.size() - 1; 0 < pos; --pos ) {
631  std::string::value_type c = name[ pos ];
632 
633  // count '<' and '>' to be able to skip template contents
634  if ( c == '>' )
635  ++tpl_open;
636  else if ( c == '<' )
637  --tpl_open;
638  else if ( tpl_open == 0 && c == ':' && 0 < pos && name[ pos-1 ] == ':' ) {
639  // found scope, strip name from it
640  name = name.substr( pos+1, std::string::npos );
641  break;
642  }
643  }
644  }
645 
646  return name;
647 }

◆ operator Bool_t()

TScopeAdapter::operator Bool_t ( ) const

Definition at line 874 of file RootType.cxx.

875 {
876  // check the validity of this scope (class)
877  if( fName.empty() ) return false;
878  if( fIsFundamental ) return true;
879 
880  // MN: rewriting this method to avoid premature header parsing
881  TClass* klass = fClass.GetClass();
882  if( !klass ) return false;
883  if( klass->HasDictionary() ) return true;
884 
885  // cout << "RootType: (Debug warning) Type " << fName << " has no dictionary!" << endl;
886  return false;
887 }

◆ operator TClass *()

TScopeAdapter::operator TClass * ( ) const
inline

Definition at line 127 of file RootType.h.

127 { return fClass.GetClass(); }

◆ operator!=()

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

Definition at line 190 of file RootType.h.

190  {
191  return ! (*this == rh);
192  }

◆ operator<()

bool TScopeAdapter::operator< ( const TScopeAdapter rh) const

Definition at line 966 of file RootType.cxx.

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

◆ operator==()

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

Definition at line 959 of file RootType.cxx.

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

◆ Properties()

TPropertyListAdapter TScopeAdapter::Properties ( ) const

Definition at line 689 of file RootType.cxx.

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

◆ SizeOf()

size_t TScopeAdapter::SizeOf ( ) const

Definition at line 760 of file RootType.cxx.

761 {
762  if (fClass.GetClass()) {
763  return fClass.GetClass()->Size();
764  } else {
765  const TDataType* fundType = gROOT->GetType(fName.c_str());
766  if ( fundType )
767  return fundType->Size();
768  }
769  return 0;
770 }

◆ TemplateArgumentAt()

TScopeAdapter TScopeAdapter::TemplateArgumentAt ( size_t  nth) const

Definition at line 814 of file RootType.cxx.

815 {
816 // this is stupid, but highly likely never called, and if it is, only once, so
817 // I don't see a reason for caching to prevent the extra loops
818  std::string name = Name( Reflex::FINAL );
819  size_t tpl_open = 0, argcount = 0;
820  std::string::size_type last = 0;
821  for ( std::string::size_type pos = 0; pos < name.size(); ++pos ) {
822  std::string::value_type c = name[pos];
823 
824  // count '<' and '>' to be able to keep templated args intact
825  if ( c == '<' ) {
826  ++tpl_open;
827  if (tpl_open == 1) last = pos+1;
828  continue;
829  } else if (c == '>') {
830  --tpl_open;
831  }
832  if ((c == ',' && tpl_open == 1) || (c == '>' && tpl_open == 0)) {
833  if ( argcount++ == nth ) {
834  // Protect against data race inside TClassEdit.
835  // https://github.com/root-project/root/issues/10353
836  // Should be fixed in root 6.26.02.
837  R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
838  std::string part =
839  TClassEdit::CleanType( name.substr(last, pos-last).c_str(), 1 );
840  return part;
841  }
842  last = pos+1; // done with part
843  }
844  }
845 
846  // should never be called
847  assert( !"miscount between TemplateArgumentSize() and TemplateArgumentAt()" );
848  return TScopeAdapter();
849 }

◆ TemplateArgumentSize()

size_t TScopeAdapter::TemplateArgumentSize ( ) const

Definition at line 852 of file RootType.cxx.

853 {
854 // this is stupid, too, see TemplateArgumentAt() above
855  std::string name = Name( Reflex::FINAL );
856  size_t tpl_open = 0, argcount = 0;
857  for ( std::string::size_type pos = 0; pos < name.size(); ++pos ) {
858  std::string::value_type c = name[pos];
859 
860  // count '<' and '>' to be able to keep templated args intact
861  if ( c == '<' ) {
862  ++tpl_open;
863  continue;
864  } else if ( c == '>' )
865  --tpl_open;
866 
867  if ((c == ',' && tpl_open == 1) || (c == '>' && tpl_open == 0))
868  ++argcount;
869  }
870  return argcount;
871 }

◆ ToType()

TTypeAdapter TScopeAdapter::ToType ( ) const
inline

Definition at line 185 of file RootType.h.

185 { return *this; }

◆ TypeAt()

TScopeAdapter TScopeAdapter::TypeAt ( size_t  nth)
static

Definition at line 588 of file RootType.cxx.

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

◆ TypeInfo()

const type_info & TScopeAdapter::TypeInfo ( ) const

Definition at line 679 of file RootType.cxx.

680 {
681  if (fIsFundamental) { // Fundamentals have no fClass.GetClass()
682  return fundamental_type(fName);
683  }
684  return *fClass.GetClass()->GetTypeInfo();
685 }

◆ TypeOf()

TScopeAdapter TScopeAdapter::TypeOf ( ) const
inline

Definition at line 186 of file RootType.h.

186 { return *this; }

◆ TypeSize()

size_t TScopeAdapter::TypeSize ( )
static

Definition at line 597 of file RootType.cxx.

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

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:
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
get_hdefs.buff
buff
Definition: get_hdefs.py:61
TScopeAdapter::TScopeAdapter
TScopeAdapter()
Definition: RootType.cxx:372
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
quiet
bool quiet
Definition: TrigGlobEffCorrValidation.cxx:190
python.PyAthena.klass
klass
Definition: PyAthena.py:133
TScopeAdapter::fIsFundamental
bool fIsFundamental
Definition: RootType.h:203
TScopeAdapter::fName
std::string fName
Definition: RootType.h:201
fundamental_type
const std::type_info & fundamental_type(const std::string &name)
Definition: RootType.cxx:448
klass
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
Reflex::SCOPED
@ SCOPED
Definition: RootType.h:27
TScopeAdapter::Name
std::string Name(unsigned int mod=Reflex::SCOPED) const
Definition: RootType.cxx:607
Reflex::FINAL
@ FINAL
Definition: RootType.h:25
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TPropertyListAdapter
Definition: RootType.h:37
gErrorIgnoreLevel
int gErrorIgnoreLevel
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
Name
JetDumper::Name Name
Definition: JetDumper.cxx:19
TScopeAdapter::Init
void Init(const std::string &name, Bool_t load, Bool_t quiet)
Definition: RootType.cxx:514
TRT_PAI_physicsConstants::mb
const double mb
1mb to cm2
Definition: TRT_PAI_physicsConstants.h:15
Reflex::QUALIFIED
@ QUALIFIED
Definition: RootType.h:26
merge.status
status
Definition: merge.py:17
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
python.root_pickle.load
def load(f, use_proxy=1, key=None)
Definition: root_pickle.py:476
python.DetectStreamerInfoChanges.class_name
class_name
Definition: DetectStreamerInfoChanges.py:60
TScopeAdapter::fClass
TClassRef fClass
Definition: RootType.h:202
python.compressB64.c
def c
Definition: compressB64.py:93
TScopeAdapter
Definition: RootType.h:119