TfRefBase Class Reference

Enable a concrete base class for use with TfRefPtr. More...

Inheritance diagram for TfRefBase:

Public Types
typedef void(*	UniqueChangedFuncPtr )(TfRefBase const *, bool)

Public Member Functions
size_t	GetCurrentCount () const
	Return the current reference count of this object. More...
bool	IsUnique () const
	Return true if only one TfRefPtr points to this object. More...
const TfRefCount &	GetRefCount () const
void	SetShouldInvokeUniqueChangedListener (bool shouldCall)

Static Public Member Functions
static TF_API void	SetUniqueChangedListener (UniqueChangedListener listener)

Friends
template<typename T >
class	TfRefPtr
template<typename T >
TfRefPtr< T >	TfCreateRefPtrFromProtectedWeakPtr (TfWeakPtr< T > const &)
	Thread-safe creation of a Tf ref pointer from a Tf weak pointer. More...

Detailed Description

Enable a concrete base class for use with TfRefPtr.

You should be familiar with the TfRefPtr type before reading further.

A class (but not an interface class) is enabled for reference counting via the TfRefPtr type by publicly deriving from TfRefBase.

For example,

*      #include "pxr/base/tf/refPtr.h"
* 
*      class Simple : public TfRefBase {
*      public:
*          TfRefPtr<Simple> New() {
*              return TfCreateRefPtr(new Simple);
*          }
*      private:
*          Simple();
*      };
*  

The class Simple can now only be manipulated in terms of a TfRefPtr<Simple>.

To disable the cost of the "unique changed" system, derive from TfSimpleRefBase instead.

Definition at line 71 of file refBase.h.

Member Function Documentation

size_t GetCurrentCount ( ) const

inline

Return the current reference count of this object.

Definition at line 84 of file refBase.h.

bool IsUnique ( ) const

inline

Return true if only one TfRefPtr points to this object.

Definition at line 89 of file refBase.h.

Friends And Related Function Documentation

TfRefPtr<T> TfCreateRefPtrFromProtectedWeakPtr ( TfWeakPtr< T > const &  p )

friend

Thread-safe creation of a Tf ref pointer from a Tf weak pointer.

This is thread-safe in the sense that the result will be either a ref pointer to a live object with non-zero ref-count, or a NULL ref pointer. However, this depends on the client to provide a guarantee to protect the pointed-to object.

Specifically, the caller must guarantee that the TfRefBase part of the pointed-to object is not destroyed during this call. It is fine if the destruction process for the object begins (due to the ref-count going to zero as another thread drops the last ref) as long as the TfRefBase portion is not destroyed. If object destruction begins because the ref-count goes to zero before this call completes, this function will reliably return a NULL ref pointer.

Note that this is not a general mechanism for safely converting weak pointers to ref pointers, because it relies on the type T to provide the above guarantee.

Definition at line 277 of file weakPtr.h.

---

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

• pxr/base/tf/refBase.h