DynWeakRef.hpp

#ifndef DYNWEAKREF_HPP
#define DYNWEAKREF_HPP

//#include "utils/Notifier.hpp" 
#include "DynObj.h"
#include "DoError.h" 
#include "RefCount.h"
#include "DORT.h" 
#include "DortInternal.h"
#include "DoBase.hpp"

 
template<class T>
struct DynWeakRef : public NotifiableI { 
    explicit DynWeakRef( ) : m_pt(0) { } 
    explicit DynWeakRef( T* pt ) : m_pt(0) { 
        InternalAssign(pt); 
    } 
    explicit DynWeakRef( DynWeakRef& dop ) : m_pt(0) { 
        InternalAssign(dop); 
    } 
    ~DynWeakRef(){ 
        InternalRelease();
    }
    
    DynWeakRef& operator = (T* pt){
        InternalRelease();
        InternalAssign(pt);
        return *this;
    }
    DynWeakRef& operator = (DynWeakRef<T>& dop){
        return operator = (dop.Get());
    }
    
    DynWeakRef& Assign( T* pt ){
        InternalRelease();
        bool r = InternalAssign( pt );
        return *this;
    }
    
    // Smart pointer access
    operator T* () { return m_pt; }
    operator T& () { return *m_pt; }
    T& operator * () { return *m_pt; }
    T* operator -> () { return m_pt; }
    T* Get() { return m_pt; }

    bool IsOk(){ return m_pt!=NULL; } 

    bool Release(){ T*pt=m_pt; InternalRelease(); return pt && !m_pt; } 

protected:    

    bool InternalAssign( T* pt ){
        DO_ASSERT_MSG(!m_pt,"T* m_pt should be NULL");
        if( !pt ) return true;
        
        typename VBaseSelect<T>::type *pt1 = (typename VBaseSelect<T>::type*)pt;
        DO_ASSERT_MSG( ((void*)pt)==((void*)pt1), "VBaseSelect<T>::type should keep ptr representation" );
        DynObjType *pdt = ::doGetType( pt1 );
        if( !pdt ) return false;
        
        // If not static, must have NotifierI or be a trackable DynObj
        NotifierI *pni = DoCasterSelect<T,NotifierI,DoIsTypeA<T,NotifierI>::v>::Cast(pt,pdt);
        if( pni ){
            if( !pni->AddNotifiable(this,NOT_EVT_DTOR) )
                return false;
            m_pt = pt;
            return true;
        }
        else return false;
    }

    void InternalRelease(){
        if( !m_pt ) return;
        
        // Get NotifierI 
        DynObjType *pdt = ::doGetType( (typename VBaseSelect<T>::type*)m_pt );
        NotifierI *pni = DoCasterSelect<T,NotifierI,DoIsTypeA<T,NotifierI>::v>::Cast(m_pt,pdt);
        if( !pni ) return;
        
        bool r = pni->RemoveNotifiable(this,NOT_EVT_DTOR);
        DO_ASSERT_MSG(r,"Should succeed removing NotifiableI");
        m_pt = NULL;
    }

    // Tracked object releases our pointer on it
    virtual bool docall OnNotify( NotifierI *pni, int evt, NotifDataI *pnd ){
        DO_ASSERT_MSG(m_pt,"Should have tracked object");
        m_pt = NULL;
        return true;
    }

    T* m_pt;
};

#endif // DYNWEAKREF_HPP

---