Main Page   Modules   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   File Members  

at::Ptr< w_ClassRef, w_RefTraits > Class Template Reference
[Smart Pointer Support]

#include <at_lifetime.h>

Inheritance diagram for at::Ptr< w_ClassRef, w_RefTraits >:

Inheritance graph
[legend]
Collaboration diagram for at::Ptr< w_ClassRef, w_RefTraits >:

Collaboration graph
[legend]
List of all members.

Public Methods

 Ptr ()
 Ptr (w_ClassRef i_ptr)
 Ptr (w_ClassRef i_ptr, bool i_takeOwnership)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>  Ptr (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
 Ptr (const Ptr &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>  Ptr (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>  Ptr (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
 ~Ptr ()
Ptr & operator= (w_ClassRef i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> Ptr & operator= (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
Ptr & operator= (const Ptr &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> Ptr & operator= (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> Ptr & operator= (PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
PointerTo< w_ClassRef >::value_type * operator-> () const
PointerTo< w_ClassRef >::value_type & operator * () const
w_ClassRef * InnerReference ()
w_ClassRef Get () const
 operator bool () const
w_ClassRef Reset (const w_ClassRef i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> Ptr & Reset (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
w_ClassRef Transfer ()
PtrView< w_ClassRef, w_RefTraits > LifeView () const
bool operator! () const
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator== (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator== (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator== (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator!= (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator!= (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator!= (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator< (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator< (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator< (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator> (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator> (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator> (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator<= (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator<= (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator<= (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator>= (const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator>= (const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)
template<typename w_ClassRefRhs, typename w_RefTraitsRhs> bool operator>= (const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &i_ptr)

Detailed Description

template<typename w_ClassRef, typename w_RefTraits>
class at::Ptr< w_ClassRef, w_RefTraits >

Ptr is a member of the set of co-operative "smart" pointers Ptr, PtrDelegate and PtrView. PtrDelegate and PtrView are intended to be used to specify pointer passing policy while Ptr is intended to be instantiated as a member or automatic variable to maintain the reference to the object being managed.

The Ptr smart pointer is designed to make it easier to work with an object whose lifetime is managed by means of reference counting.

With an ordinary pointer, you must remember to increment a reference count when you start using the object, and decrement a reference count when you are done with the object. (e.g. implemented with methods AddRef() and Release() as in COM or add() and dec() as with alternative implemenatations).

The problem is that it is very easy to forget to do an AddRef() or a Release(), especially when errors occur.

An Ptr smart pointer solves this problem, by doing the AddRef() and Release() for you automatically.

How is this accomplished? Very simply: When an Ptr pointer is copied or assigned to another one, the constructor or overloaded assignment operator automatically does an AddRef(). Similarly, when an Ptr pointer is deleted or goes out of scope, its destructor automatically does a Release().

See also:
at_lifetime.h , PtrDelegate , PtrView


Constructor & Destructor Documentation

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr   [inline]
 

Default contructor for an Ptr. This sets the managed pointer to null.

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr w_ClassRef    i_ptr [inline]
 

This method contructs an Ptr from a regular pointer.

Parameters:
i_ptr  The regular pointer to be copied (optional).

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr w_ClassRef    i_ptr,
bool    i_takeOwnership
[inline]
 

Constructs an Ptr smart pointer from a regular pointer, optionally taking ownership of the managed pointer (by bumping his reference count).

Parameters:
ptr  The regular pointer to be copied.
i_takeOwnership  A flag indicating whether or not to take ownership of the managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

Contructs an Ptr from another Ptr which may be based on a different underlying pointer type.

Parameters:
i_ptr  A reference to the Ptr being copied.

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr const Ptr< w_ClassRef, w_RefTraits > &    i_ptr [inline]
 

This method provides an explicit copy constructor for Ptr. Apparently, without such a constructor, the compiler is unable (or unwilling) to use the above templated constructor, and instead generates its own code that does the wrong thing.

Parameters:
i_ptr  A reference to the Ptr pointer being copied.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

Contructs an Ptr from an PtrView.

Parameters:
i_ptr  A reference to the PtrView being copied.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
at::Ptr< w_ClassRef, w_RefTraits >::Ptr const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

Contructs an Ptr from an PtrDelegate.

Parameters:
i_ptr  The PtrDelegate smart pointer being copied.

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::~Ptr   [inline]
 

The Ptr destructor must make sure that the reference count of the pointer that is being managed is decremented.


Member Function Documentation

template<typename w_ClassRef, typename w_RefTraits>
w_ClassRef at::Ptr< w_ClassRef, w_RefTraits >::Get   const [inline]
 

Get() allows access to the inner pointer value.

Returns:
The address of the managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
w_ClassRef* at::Ptr< w_ClassRef, w_RefTraits >::InnerReference   [inline]
 

InnerReference() releases the managed pointer, and returns the address of the private data member that is used to store the address of the managed pointer. This is intended for use in legacy API's that require the address of a pointer that will get filled in. Use of this pointer for other circumstances is discouraged.

Returns:
The address of the private data member used to store the address of the managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
PtrView< w_ClassRef, w_RefTraits > at::Ptr< w_ClassRef, w_RefTraits >::LifeView   const [inline]
 

This helper method returns an PtrView version of this Ptr pointer.

Returns:
An PtrView version of this Ptr pointer.

template<typename w_ClassRef, typename w_RefTraits>
PointerTo<w_ClassRef>::value_type& at::Ptr< w_ClassRef, w_RefTraits >::operator *   const [inline]
 

This method overloads the dereference operator-*(ptr)

Returns:
The object being pointed to.

template<typename w_ClassRef, typename w_RefTraits>
at::Ptr< w_ClassRef, w_RefTraits >::operator bool   const [inline]
 

This defines the bool conversion.

Returns:
A flag indicating whether (true) or not (false) the managed pointer's address is non-NULL.

template<typename w_ClassRef, typename w_RefTraits>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator!   const [inline]
 

This method overloads operator!.

Returns:
A boolean indicating whether (true) or not (false) this Ptr pointer is zero.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator!= const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator!= const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator!= const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the '!=' operator for the cases where an Ptr is being tested for inequality to an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '!=' operator.
Returns:
A boolean indicating whether (true) or not (false) the two pointers on each side of the '!=' sign are unequal, i.e. point to different objects.

template<typename w_ClassRef, typename w_RefTraits>
PointerTo<w_ClassRef>::value_type* at::Ptr< w_ClassRef, w_RefTraits >::operator->   const [inline]
 

Operator -> allows the access to the managed pointer -> operator.

Returns:
The address of the managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator< const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator< const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator< const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the < operator for the cases where an Ptr is being tested to see if it is less than an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '<' operator.
Returns:
A boolean indicating whether (true) or not (false) the left-hand pointer is less than the right-hand pointer, i.e. whether the address of the left-hand managed pointer is less than the address of the right-hand managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator<= const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator<= const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator<= const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the <= operator for the cases where an Ptr is being tested to see if it is less than or equal to an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '<=' operator.
Returns:
A boolean indicating whether (true) or not (false) the left-hand pointer is less than or equal to the right-hand pointer, i.e. whether the address of the left-hand managed pointer is less than or equal to the address of the right-hand managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::operator= PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This method overloads the assignment operator for the case where an PtrDelegate is being assigned to an Ptr. This will set the PtrDelegate passed in to null. The concept is that the job of an PtrDelegate is to describe the policy of passing and returning pointers hence once the pointer is placed in it's final resting place, the PtrDelegate is no longer needed (and should not be used).

Parameters:
i_ptr  A reference to the PtrDelegate pointer on the right-hand side of the '=' sign.
Returns:
A reference to the Ptr pointer on the left-hand side of the '=' sign.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::operator= const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This method overloads the assignment operator for the case where an Ptr is being set equal to an PtrView.

Parameters:
i_ptr  A reference to the PtrView pointer on the right-hand side of the '=' sign.
Returns:
A reference to the Ptr pointer on the left-hand side of the '=' sign.

template<typename w_ClassRef, typename w_RefTraits>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::operator= const Ptr< w_ClassRef, w_RefTraits > &    i_ptr [inline]
 

Copy assignment.

If such a method is not provided, the compiler is unable to use the above template version of overloaded assignment, and instead generates its own code that does the wrong thing.

Parameters:
i_ptr  A reference to the Ptr pointer on the right-hand side of the '=' sign.
Returns:
A reference to the Ptr pointer on the left-hand side of the '=' sign.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::operator= const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

Assignment operator for the case where an Ptr is being set equal to another Ptr which may be based on a different underlying pointer type.

Parameters:
i_ptr  A reference to the Ptr pointer on the right-hand side of the '=' sign.
Returns:
A reference to the Ptr pointer on the left-hand side of the '=' sign.

template<typename w_ClassRef, typename w_RefTraits>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::operator= w_ClassRef    i_ptr [inline]
 

Ptr ( regular pointer ) assignment This method overloads the assignment operator for the case where an Ptr is being set equal to a regular pointer.

Parameters:
i_ptr  The regular pointer on the right-hand side of the '=' sign.
Returns:
A reference to the Ptr pointer on the left-hand side of the '=' sign.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator== const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator== const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator== const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the '==' operator for the cases where an Ptr is being tested for equality to an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '==' operator.
Returns:
A boolean indicating whether (true) or not (false) the two pointers on each side of the '==' sign are equal, i.e. point to the same object.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator> const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator> const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator> const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the > operator for the cases where an Ptr is being tested to see if it is greater than an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '>' operator.
Returns:
A boolean indicating whether (true) or not (false) the left-hand pointer is greater than the right-hand pointer, i.e. whether the address of the left- hand managed pointer is greater than the address of the right-hand managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator>= const PtrView< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator>= const Ptr< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
bool at::Ptr< w_ClassRef, w_RefTraits >::operator>= const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

These methods overload the >= operator for the cases where an Ptr is being tested to see if it is greater than or equal to an PtrDelegate, an Ptr, or an PtrView.

Parameters:
i_ptr  A reference to the smart pointer on the right-hand side of the '>=' operator.
Returns:
A boolean indicating whether (true) or not (false) the left-hand pointer is greater than or equal to the righthand pointer, i.e. whether the address of the left-hand managed pointer is greater than or equal to the address of the right-hand managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
template<typename w_ClassRefRhs, typename w_RefTraitsRhs>
Ptr& at::Ptr< w_ClassRef, w_RefTraits >::Reset const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > &    i_ptr [inline]
 

This helper method increments the reference count of the object managed by the PtrDelegate parameter. This is used in the rare case where the PtrDelegate smart pointer is required later in execution.

Parameters:
i_ptr  A reference to the PtrDelegate pointer whose managed pointer is to be "adopted".
Returns:
The address of the "adopted" managed pointer.

template<typename w_ClassRef, typename w_RefTraits>
w_ClassRef at::Ptr< w_ClassRef, w_RefTraits >::Reset const w_ClassRef    i_ptr [inline]
 

Reset() will increment the reference count of the pointer passed into i_ptr and will also replace the managed pointer in this with i_ptr.

Parameters:
i_ptr  The address of the new managed pointer.
Returns:
The value of i_ptr

template<typename w_ClassRef, typename w_RefTraits>
w_ClassRef at::Ptr< w_ClassRef, w_RefTraits >::Transfer   [inline]
 

This helper method returns the pointer being managed by this and setting this managed pointer to null. This effectively passes back to the caller the responsibility of decrementing the reference count.

Returns:
The address of the managed pointer.


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

Generated for Austria by doxygen and MakeXS at Sun Oct 24 17:35:34 PDT 2004