class TClassRef


TClassRef is used to implement a permanent reference to a TClass
object.  In particular this reference will change if and when the
TClass object is regenerated.  This regeneration usually happens
when a library containing the described class is loaded after a
file containing an instance of this class has been opened.

The references kept track of using an intrusive double linked list.
The intrusive list is maintained by TClass::AddRef and
TClass::RemoveRef.  The 'start' of the list is held in
TClass::fRefStart.

Function Members (Methods)

public:

	~TClassRef()
TClass*	GetClass() const
const char*	GetClassName()
TClass*	operator TClass *() const
TClass*	operator->() const
TClassRef&	operator=(const TClassRef& rhs)
TClassRef&	operator=(TClass* rhs)
void	Reset()
void	SetName(const char* new_name)
	TClassRef()
	TClassRef(TClass* cl)
	TClassRef(const char* classname)
	TClassRef(const TClassRef&)

private:

void	Assign(const TClassRef&)
void	Assign(TClass*)
TClass*	InternalGetClass() const

Data Members

private:

string	fClassName	Name of referenced class
TClassconst	fClassPtr	! Ptr to the permanent TClass ptr/reference

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

TClassRef(const TClassRef& )

 Copy ctor, increases reference count to original TClass object.

TClassRef(const char* classname)

 Create reference to specified class name, but don't set referenced
 class object.

TClassRef(TClass* cl)

 Add reference to specified class object.

void Assign(const TClassRef& )

 Assignment operator implementation, increases reference count to original class object.
 This routines assumes that the copy actually need to be done.

void Assign(TClass* )

 Assignment operator, increases reference count to original class object.
 This routines assumes that the copy actually need to be done.

TClass * InternalGetClass() const

 Return the current TClass object corresponding to fClassName.

TClassRef()

{}

TClassRef & operator=(const TClassRef& rhs)

 Inline implementation of operator= to speed the no-op case.

TClassRef & operator=(TClass* rhs)

 Inline implementation of operator= to speed the no-op case.

~TClassRef()

{ }

void SetName(const char* new_name)

const char * GetClassName()

{ return fClassName.c_str(); }

TClass * GetClass() const

{ return (fClassPtr && *fClassPtr) ? *fClassPtr : InternalGetClass(); }

void Reset()

{ fClassPtr = 0; }

TClass* operator->() const

{ return (fClassPtr && *fClassPtr) ? *fClassPtr : InternalGetClass(); }