---

at_lifetime.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_lifetime_h_x
#define x_at_lifetime_h_x 1

#include "at_exports.h"
#include "at_assert.h"
#include "at_types.h"

#include "at_pointers.h"

// Austria namespace
namespace at
{
        
// ======== Forward references =========================================
//

template < typename w_ClassRef > class COMPtrTraits;
template < typename w_ClassRef > class PtrTraits;
template <
    typename w_ClassRef,
    typename w_First,
    typename w_Second
>
class PtrSelect
{
    public:

    typedef w_First         type;
};

template <
    typename w_ClassRef,
    typename w_RefTraits = typename PtrSelect<
        w_ClassRef,
        PtrTraits< w_ClassRef >,
        COMPtrTraits< w_ClassRef >
    >::type
> class PtrView;


#define AT_Friend_LifeTime  \
    template < \
        typename wa_ClassRef, \
        typename wa_RefTraits \
    > friend class Ptr; \
// end macro

template <
    typename w_ClassRef,
    typename w_RefTraits = typename PtrSelect<
        w_ClassRef,
        PtrTraits< w_ClassRef >,
        COMPtrTraits< w_ClassRef >
    >::type
> class Ptr;

#define AT_Friend_LifeView  \
    template < \
        typename wa_ClassRef, \
        typename wa_RefTraits \
    > friend class PtrView; \
// end macro

#define AT_Friend_LifeLine \
    template < \
        typename wa_ClassRef, \
        typename wa_RefTraits \
    > friend class PtrDelegate; \
// end macro


// ======== PtrTarget ===========================================
class AUSTRIA_EXPORT PtrTarget
{
    public:

    virtual ~PtrTarget() {};  // Virtual destructor

    virtual int AddRef() const = 0;

    virtual int Release() const = 0;
};


// ======== PtrStyle ==================================================
class PtrStyle
{
    public:

    enum {

        // ======== InitCount =========================================
        InitCount = 0,

        // ======== DeleteCheck =======================================
        DeleteCheck = 1
    };


    // ======== BaseType ==============================================
    struct BaseType
    {
    };


    // ======== ZeroReferenceAction ===================================
    template <typename w_type>
    inline static void ZeroReferenceAction( w_type i_obj )
    {
        delete i_obj;
    }
    
};


// ======== PtrCOMStyle ===============================================
class PtrCOMStyle
{
    public:

    enum {

        // ======== InitCount =========================================
        InitCount = 1,
        
        // ======== DeleteCheck =======================================
        DeleteCheck = 0
    };


    // ======== BaseType ==============================================
    struct BaseType
    {
        typedef int                             PtrTargetMarker;
    };
    
    // ======== ZeroReferenceAction ===================================
    template <typename w_type>
    inline static void ZeroReferenceAction( w_type i_obj )
    {
        delete i_obj;
    }
    
};


// ======== PtrTarget_Helpers =========================================
template <typename w_count_t, typename w_ptr_style_traits = PtrStyle>
class PtrTarget_Generic;

template <typename w_count_t, typename w_ptr_style_traits>
class PtrTarget_Helpers
{
    public:


    // ======== IsRefCountOne =========================================
    static bool IsRefCountOne(
        const PtrTarget_Generic<w_count_t,w_ptr_style_traits> * i_ptr
    )
    {
        return 1 == i_ptr->m_ref_count;
    }
};

// ======== PtrTarget_Generic =========================================
template <typename w_count_t, typename w_ptr_style_traits>
class PtrTarget_Generic
  : public w_ptr_style_traits::BaseType
{
    public:

    typedef w_ptr_style_traits                  t_ptr_style;

    friend class PtrTarget_Helpers<w_count_t,w_ptr_style_traits>;

    private:

    // for unit test only.
    friend class AT_TEST_LifeControlExp;
    
    enum {
        
        // ======== DoDeleteCheck =====================================
        DoDeleteCheck = 
            OSTraitsBase::DebugBuild
            && ( ! t_ptr_style::InitCount )
            && t_ptr_style::DeleteCheck
    };

    // m_ref_count is mutable becuase references may increment
    // or decrement on const versions of this object as well
    // as the non-const version.
    mutable w_count_t                           m_ref_count;

    // friend class declaration that allows the MPT_Finder
    // to find the PtrTargetMarker.
    template <
        typename wa_D,
        typename wa_TD
    > friend struct MPT_Finder;
    
    // ======== AssertGreater ==========================================
    template <typename w_count_basis, typename w_compare_t>
    static inline w_count_basis AssertGreater( w_count_basis i_v, w_compare_t i_cmp )
    {
        AT_Assert( i_v > i_cmp );
        return i_v;
    }
    
    public:
    //
    // this should force derived destructors to be virtual
    virtual ~PtrTarget_Generic() {};  // Virtual destructor
    
    PtrTarget_Generic()
      : m_ref_count( t_ptr_style::InitCount )
    {
    }

    PtrTarget_Generic( const PtrTarget_Generic & )
      : m_ref_count( t_ptr_style::InitCount )
    {
    }

    PtrTarget_Generic & operator = ( const PtrTarget_Generic & )
    {
        return * this;
    }

    int AddRef() const
    {
        return AssertGreater(
            ++ m_ref_count,
            static_cast<int>( t_ptr_style::InitCount )
        );
    }

    int Release() const
    {

        int l_ret_val = AssertGreater( m_ref_count --, 0 ) - 1;
        
        if ( l_ret_val == 0 )
        {
            // Here we do an extra decrement if we are doing
            // assert checking.  This is because we want to
            // find cases where deleted pointers have their
            // reference count incremented.  There is no
            // guarentee that this check will work because the
            // allocated memory may be allocated.
            if ( DoDeleteCheck  )
            {
                -- m_ref_count;
            }

            // ZeroReferenceAction usually deletes the
            // pointer passed in.
            t_ptr_style::ZeroReferenceAction( this );
            return 0;
        }

        return l_ret_val;
    }
};

// ======== IsRefCountOne =============================================
template <typename w_count_t, typename w_ptr_style_traits>
bool IsRefCountOne(
    const PtrTarget_Generic<w_count_t, w_ptr_style_traits> * i_ptr
) {

    if ( i_ptr )
    {
        return PtrTarget_Helpers<w_count_t, w_ptr_style_traits>::IsRefCountOne( i_ptr );
    }
    else
    {
        return false;
    }
}

// ======== PtrTarget_Basic =========================================
AUSTRIA_TEMPLATE_EXPORT(PtrTarget_Generic, int)
typedef PtrTarget_Generic<int> PtrTarget_Basic;



// ======== PtrTraits =========================================
template <typename w_ClassRef>
class PtrTraits
{
    public:

    static inline w_ClassRef FixRawPtrRefCount( w_ClassRef i_ptr )
    {
        if ( i_ptr )
        {
            i_ptr->AddRef();
        }
        return i_ptr;
    }

    static inline void IncRefCount( w_ClassRef i_ptr )
    {
        i_ptr->AddRef();
    }

    static inline void DecRefCount( w_ClassRef i_ptr )
    {
        i_ptr->Release();
    }
};

    
// ======== PtrDelegate ================================================
template <
    typename w_ClassRef,
    typename w_RefTraits = typename PtrSelect<
        w_ClassRef,
        PtrTraits< w_ClassRef >,
        COMPtrTraits< w_ClassRef >
    >::type
>
class PtrDelegate
{
    AT_Friend_LifeView
    AT_Friend_LifeTime
    AT_Friend_LifeLine

    mutable w_ClassRef m_ptrVal;

    inline w_ClassRef ReleasePointee( w_ClassRef i_ptrVal )
    {
                //
                // The order in which this happens is critical.
                // The new pointer must be in place before decrementing
                // the reference count.
                // 
                
        // Save a pointer to the old managed pointer.
        w_ClassRef l_ptrVal = m_ptrVal;

        // Point to the new managed pointer.
        m_ptrVal = i_ptrVal;

        // Decrement the old managed pointer's reference count.
        if ( l_ptrVal ) {
            w_RefTraits::DecRefCount( l_ptrVal );
        }

        // Return a regular pointer to the new managed pointer.
        return i_ptrVal;
    }

public:

    inline PtrDelegate(
        const PtrDelegate & i_ptr
    )
      : m_ptrVal( i_ptr.Transfer() )
    {
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate(
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.Transfer() )
    {
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate(
        const Ptr < w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
        // Increment the managed pointer's reference count.
        if ( m_ptrVal ) {
            w_RefTraits::IncRefCount( m_ptrVal );
        }
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate(
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
        // Increment the managed pointer's reference count.
        if ( m_ptrVal ) {
            w_RefTraits::IncRefCount( m_ptrVal );
        }
    }


    inline PtrDelegate( w_ClassRef i_ptr = 0 )
      : m_ptrVal( w_RefTraits::FixRawPtrRefCount( i_ptr ) )
    {
    }

    inline PtrDelegate( w_ClassRef i_ptr, bool i_takeOwnership )
      : m_ptrVal( i_ptr )
    {
        if ( i_takeOwnership ) {
            if ( i_ptr ) {
                w_RefTraits::IncRefCount( i_ptr );
            }
        }
    }

    inline ~PtrDelegate()
    {
        if ( m_ptrVal ) {
            w_RefTraits::DecRefCount( m_ptrVal );
        }
    }

    inline PtrDelegate & operator= ( const w_ClassRef i_ptr )
    {

        // Perform assignment and use the FixRawPtrRefCount
        // RefTraits method to fix the reference count if
        // needed.
        ReleasePointee( w_RefTraits::FixRawPtrRefCount( i_ptr ) );

        // Return a reference to the PtrDelegate, so that
        // assignment operations can be chained together.
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate & operator= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        // Perform assignment by transferring responsibility.
        //
        ReleasePointee( i_ptr.Transfer() );

        // Return a reference to the destination PtrDelegate,
        // so that assignment operations can be chained together.
        return * this;
    }

    inline PtrDelegate & operator= (
        const PtrDelegate & i_ptr
    )
    {
        // Perform assignment by transferring responsibility.
        //
        ReleasePointee( i_ptr.Transfer() );

        // Return a reference to the destination PtrDelegate,
        // so that assignment operations can be chained together.
        return * this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate & operator= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {

        w_ClassRef l_ptrVal = i_ptr.m_ptrVal;

        // Increment the new managed pointer's reference count.
        if ( l_ptrVal )
        {
            w_RefTraits::IncRefCount( l_ptrVal );
        }

        // Perform assignment
        //
        ReleasePointee( l_ptrVal );

        // Return a reference to the PtrDelegate, so that
        // assignment operations can be chained together.
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrDelegate & operator= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {

        w_ClassRef l_ptrVal = i_ptr.m_ptrVal;

        // Increment the new managed pointer's reference count.
        if ( l_ptrVal != 0 )
        {
            w_RefTraits::IncRefCount( l_ptrVal );
        }

        // Perform assignment
        //
        ReleasePointee( l_ptrVal );

        // Return a reference to the PtrDelegate, so that
        // assignment operations can be chained together.
        return *this;
    }

    inline w_ClassRef Transfer() const
    {
        // Save a pointer to the pointer.
        w_ClassRef l_ptrVal = m_ptrVal;

        m_ptrVal = 0;

        return l_ptrVal;
    }

    inline PtrView< w_ClassRef, w_RefTraits > LifeView() const
    {
        return PtrView< w_ClassRef, w_RefTraits >( m_ptrVal );
    }

    inline typename PointerTo<w_ClassRef>::value_type * operator-> () const
    {
        return & ( * m_ptrVal );
    }

    inline typename PointerTo<w_ClassRef>::value_type & operator* () const
    {
        return * m_ptrVal;
    }

    inline w_ClassRef Get() const
    {
        return m_ptrVal;
    }

    inline operator bool () const
    {
        return m_ptrVal != 0;
    }

    inline bool operator! () const
    {
        return m_ptrVal == 0;
    }

    // operator ==
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    // operator !=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    // operator <
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    // operator >
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    // operator <=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    // operator >=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }
};


// ======== Ptr ================================================
template < typename w_ClassRef, typename w_RefTraits >
class Ptr
{
    AT_Friend_LifeView
    AT_Friend_LifeTime
    AT_Friend_LifeLine

    mutable w_ClassRef m_ptrVal;

private:

    inline w_ClassRef ReleasePointee( w_ClassRef i_ptrVal )
    {
                //
                // The order in which this happens is critical.
                // The new pointer must be in place before decrementing
                // the reference count.
                // 
                
        // Save a pointer to the old managed pointer.
        w_ClassRef l_ptrVal = m_ptrVal;

        // Point to the new managed pointer.
        m_ptrVal = i_ptrVal;

        // Decrement the old managed pointer's reference count.
        if ( l_ptrVal ) {
            w_RefTraits::DecRefCount( l_ptrVal );
        }

        // Return a regular pointer to the new managed pointer.
        return i_ptrVal;
    }

public:

    inline Ptr()
      : m_ptrVal( 0 )
    {
    }

    inline Ptr( w_ClassRef i_ptr )
      : m_ptrVal( w_RefTraits::FixRawPtrRefCount( i_ptr ) )
    {
    }

    inline Ptr( w_ClassRef i_ptr, bool i_takeOwnership )
      : m_ptrVal( i_ptr )
    {
        if ( i_takeOwnership ) {
            if ( m_ptrVal ) {
                w_RefTraits::IncRefCount( m_ptrVal );
            }
        }
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr(
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
        // Bump the managed pointer's reference count.
        if ( m_ptrVal ) {
            w_RefTraits::IncRefCount(m_ptrVal);
        }
    }

    inline Ptr(
        const Ptr & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
        // Bump the managed pointer's reference count.
        if ( m_ptrVal ) {
            w_RefTraits::IncRefCount(m_ptrVal);
        }
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr(
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
        // Bump the managed pointer's reference count.
        if ( m_ptrVal ) {
            w_RefTraits::IncRefCount(m_ptrVal);
        }
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr(
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.Transfer() )
    {
    }

    inline ~Ptr()
    {
        // Releases the managed pointer
        if ( m_ptrVal ) {
            w_RefTraits::DecRefCount( m_ptrVal );
        }
    }

    inline Ptr & operator= (
        w_ClassRef              i_ptr
    )
    {
        // Release the old managed pointer, and adopt the new one.
        ReleasePointee( w_RefTraits::FixRawPtrRefCount( i_ptr ) );

        // Return a reference to the Ptr pointer on
        // the left-hand side of the '=' sign, so that assign-
        // ment operations can be chained together.
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >

    inline Ptr & operator=(
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        // this will increment the reference count
        // of the pointer passed in and replace the
        // pointer currently being managed by this.
        
        Reset( i_ptr.m_ptrVal ); // pointer conversion happens here

        // Return a reference to the Ptr pointer on
        // the left-hand side of the '=' sign, so that assign-
        // ment operations can be chained together.
        return *this;
    }

    inline Ptr & operator= (
        const Ptr & i_ptr
    )
    {
        // this will increment the reference count
        // of the pointer passed in and replace the
        // pointer currently being managed by this.
        Reset( i_ptr.m_ptrVal );
        
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr & operator=(
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        // this will increment the reference count
        // of the pointer passed in and replace the
        // pointer currently being managed by this.
        Reset( i_ptr.m_ptrVal );
        
        // Return a reference to the Ptr pointer on
        // the left-hand side of the '=' sign, so that assign-
        // ment operations can be chained together.
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr & operator=(
        PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        // Transfer the PtrDelegate to this.  The optimization
        // for passing PtrDelegate is that the 
        
        ReleasePointee( i_ptr.Transfer() );

        // Return a reference to the Ptr pointer on
        // the left-hand side of the '=' sign, so that assign-
        // ment operations can be chained together.
        return *this;
    }

    inline typename PointerTo<w_ClassRef>::value_type * operator-> () const
    {
        return & ( * m_ptrVal );
    }

    inline typename PointerTo<w_ClassRef>::value_type & operator* () const
    {
        return * m_ptrVal;
    }

    inline w_ClassRef * InnerReference()
    {
        // Release the managed pointer.
        ReleasePointee( 0 );

        // Return the address of the private data member used
        // to store the address of the managed pointer.
        return & m_ptrVal;
    }

    inline w_ClassRef Get() const
    {
        return m_ptrVal;
    }

    inline operator bool () const
    {
        return m_ptrVal != 0;
    }

    inline w_ClassRef Reset( const w_ClassRef i_ptr )
    {
        // Add a reference to the regular pointer's managed pointer.
        if ( i_ptr ) {
            w_RefTraits::IncRefCount( i_ptr );
        }

        // Set this Ptr equal to the regular pointer.
        ReleasePointee( i_ptr );

        return i_ptr;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline Ptr & Reset(
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        Reset( i_ptr.Get() );
        
        return * this;
    }

    inline w_ClassRef Transfer()
    {
        w_ClassRef l_ptr = m_ptrVal;

        m_ptrVal = 0;

        return l_ptr;
    }

    inline PtrView< w_ClassRef, w_RefTraits > LifeView() const
    {
        return PtrView< w_ClassRef, w_RefTraits >( m_ptrVal );
    }

    // operator !
    inline bool operator ! () const
    {
        return m_ptrVal == 0;
    }

    // operator ==
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    // operator !=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    // operator <
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    // operator>=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    // operator>=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }
};


// ======== PtrView ================================================
template < typename w_ClassRef, typename w_RefTraits >

class PtrView
{
    AT_Friend_LifeView
    AT_Friend_LifeTime
    AT_Friend_LifeLine

    mutable w_ClassRef m_ptrVal;

public:

    inline PtrView( w_ClassRef i_ptr = 0 )
      : m_ptrVal( i_ptr )
    {
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView(
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
    }

    inline PtrView(
        const PtrView & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView(
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView(
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
      : m_ptrVal( i_ptr.m_ptrVal )
    {
    }

    inline PtrView< w_ClassRef, w_RefTraits > & operator= (
        const w_ClassRef i_ptr
    )
    {
        m_ptrVal = i_ptr;
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView & operator= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        m_ptrVal = i_ptr.m_ptrVal;
        return *this;
    }

    inline PtrView & operator= (
        const PtrView & i_ptr
    )
    {
        m_ptrVal = i_ptr.m_ptrVal;
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView & operator= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        m_ptrVal = i_ptr.m_ptrVal;
        return *this;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline PtrView & operator= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        m_ptrVal = i_ptr.m_ptrVal;
        return *this;
    }

    inline typename PointerTo<w_ClassRef>::value_type * operator-> () const
    {
        return & ( * m_ptrVal );
    }

    inline typename PointerTo<w_ClassRef>::value_type & operator* () const
    {
        return * m_ptrVal;
    }

    inline w_ClassRef Get() const
    {
        return m_ptrVal;
    }

    inline PtrView< w_ClassRef > LifeView() const
    {
        return *this;
    }

    inline operator bool() const
    {
        return m_ptrVal != 0;
    }

    inline bool operator! () const
    {
        return m_ptrVal == 0;
    }

    // operator ==
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator== (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal == i_ptr.m_ptrVal;
    }

    // operator !=
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator!= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal != i_ptr.m_ptrVal;
    }

    // operator <
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator< (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal < i_ptr.m_ptrVal;
    }

    // operator >
    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator> (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal > i_ptr.m_ptrVal;
    }

    // operator <=

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs> & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator<= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal <= i_ptr.m_ptrVal;
    }

    // operator >=

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrDelegate< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const Ptr< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }

    template < typename w_ClassRefRhs, typename w_RefTraitsRhs >
    inline bool operator>= (
        const PtrView< w_ClassRefRhs, w_RefTraitsRhs > & i_ptr
    )
    {
        return m_ptrVal >= i_ptr.m_ptrVal;
    }
};
 // end of SmartPointerTrio ( Doxygen group )


// ======== Pointer =================================================
template < typename w_ClassRef >
class Pointer
{
    public:

        mutable w_ClassRef m_ptrVal;

    private:

        inline void DeletePointee()
        {
            if ( m_ptrVal ) {
                delete m_ptrVal;
            }
        }

        inline w_ClassRef DeletePointee( w_ClassRef i_ptrVal )
        {
            // Save a pointer to the old managed pointer.
            // ----------------------------------
            w_ClassRef l_ptrVal = m_ptrVal;

            // Point to the new managed pointer.
            // -------------------------
            m_ptrVal = i_ptrVal;
        
            // Delete the old managed pointer.
            // -----------------------
            if ( l_ptrVal ) {
                delete l_ptrVal;
            }
        
            // Return a regular pointer to the new managed pointer.
            // -----------------------------------------
            return i_ptrVal;
        }
    
    public:

        inline Pointer( w_ClassRef i_ptr = 0 )
          : m_ptrVal( i_ptr )
        {
        }

        inline Pointer(
            const Pointer< w_ClassRef > & i_ptr )

          : m_ptrVal( i_ptr.m_ptrVal )
        {
            // Zero out the managed pointer address in the Pointer
            // being copied, so that it is impossible to delete
            // the managed pointer twice accidentally.
            // ------------------------------------------------
            i_ptr.m_ptrVal = 0;
        }

        inline ~Pointer()
        {
            DeletePointee();
        }

        inline Pointer & operator= ( const w_ClassRef i_ptr )
        {
            // Delete the old managed pointer, and replace it with the
            // new one.
            // -----------------------------------------------
            DeletePointee( i_ptr );

            // Return a reference to the Pointer on the left-
            // hand side of the '=' sign, so that assignment
            // operations can be chained together.
            // ----------------------------------------------
            return *this;
        }

        inline Pointer & operator= (
            const Pointer< w_ClassRef > & i_ptr )
        {
            // If the two AT_Pointers both point to the same
            // managed pointer, then just return.
            // ---------------------------------------------
            if ( & m_ptrVal == & i_ptr.m_ptrVal ) {
                return *this;
            }

            // Save the address of the new managed pointer.
            // ------------------------------------
            w_ClassRef l_ptrVal = i_ptr.m_ptrVal;

            // Zero out the managed pointer's address in the Pointer
            // on the right-hand side of the '=' sign, so that
            // the managed pointer can't be deleted twice accidentally.
            // ------------------------------------------------
            i_ptr.m_ptrVal = 0;

            // Delete the old managed pointer, and store the new managed pointer's
            // address in the Pointer on the left-hand side of
            // the '=' sign.
            // ---------------------------------------------------
            DeletePointee( l_ptrVal );

            // Return a reference to the Pointer on the left-
            // hand side of the '=' sign, so that assignment
            // operations can be chained together.
            // ----------------------------------------------
            return *this;
        }

                inline typename PointerTo<w_ClassRef>::value_type * operator->() const
                {
                        return & ( * m_ptrVal );
                }

        inline typename PointerTo<w_ClassRef>::value_type & operator* () const
        {
            return * m_ptrVal;
        }

        inline operator w_ClassRef () const
        {
            return m_ptrVal;
        }

        inline operator bool () const
        {
            return m_ptrVal != 0;
        }

        inline w_ClassRef Transfer()
        {
            w_ClassRef l_ptrVal = m_ptrVal;

            m_ptrVal = 0;
        
            return l_ptrVal;
        }
};


// ======== IsRefCountOne =============================================
template < typename w_ClassRef, typename w_RefTraits >
inline bool IsRefCountOne(
    const Ptr<w_ClassRef,w_RefTraits> & i_ptr
) {

    if ( i_ptr )
    {
        return IsRefCountOne( i_ptr.Get() );
    }
    else
    {
        return false;
    }
}



#undef AT_Friend_LifeTime
#undef AT_Friend_LifeView
#undef AT_Friend_LifeLine

}; // namespace
#endif // x_at_lifetime_h_x

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