DynObjPtr.hpp

#ifndef DYNOBJPTR_HPP
#define DYNOBJPTR_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 DynObjPtr : public NotifiableI { 
    DynObjPtr( ) : m_pt(0), m_flags(0) { } 
    
    explicit DynObjPtr( T* pt, bool try_strong_ref=false ) : m_pt(0), m_flags(0), m_pni(0) { 
        InternalAssign(pt,try_strong_ref); 
    } 
    explicit DynObjPtr( DynObjPtr& dop ) : m_pt(0), m_flags(0), m_pni(0) { 
        InternalAssign(dop,dop.HasStrongRef()); 
    } 
    ~DynObjPtr(){ 
        InternalRelease();
    }
    
    DynObjPtr& operator = (T* pt){
        InternalRelease();
        InternalAssign( pt, false );
        return *this;
    }
    
    DynObjPtr& operator = (DynObjPtr<T>& dop){
        return operator = (dop.Get());
    }
    
    DynObjPtr& Assign( T* pt, bool try_strong_ref=false ){
        InternalRelease();
        bool r = InternalAssign( pt, try_strong_ref );
        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; }

    enum{ isStatic=1, hasDoRef=2, hasWeakRef=4, hasStrongRef=8 };
    
    bool HasStrongRef(){ return m_pt && m_flags&hasStrongRef; } 
    
    bool IsOk(){ return m_pt!=NULL; } 

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

protected:    

    bool InternalAssign( T* pt, int try_strong_ref ){
        DO_ASSERT_MSG(!m_pt,"T* m_pt should be NULL");
        if( !pt ) return true;
        m_flags = 0;
        
        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;
        //int off;
        DynObjType *pdt_outer = NULL;
        
        if( doIsStatic(pt,pdt) ){
            // Trust the static object
            m_pt = pt;
            m_flags |= isStatic;
            return true;
        }

        // Should we add a strong ref?
        RefCountI *prci = NULL;
        if( try_strong_ref ){
            prci = DoCasterSelect<T,RefCountI,DoIsTypeA<T,RefCountI>::v>::Cast(pt,pdt);
            if( prci ){
                prci->IncRef();
                m_flags |= hasStrongRef;
                m_pt = pt;
                // # If the type is from main, it is enough with a strong ref (don't need weak ref)
                if( ::doIsMainObject(pt1,pdt)>0 ){
                    // This is an indicator
                    return true;
                }
            }
            // Nested call into function?
            if( try_strong_ref==2 )
                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) )
                goto Failed_ReleaseStrong;
            m_flags |= hasWeakRef;
            m_pni = pni;
            m_pt = pt;
        }
        else {
            // Only tracked DynObj possible now
            DortInternalI *pdorti = (DortInternalI*)doGetObj( &DORT, DORTINTERNALI_TYPE_ID ); 
            if( !pdorti ) goto Failed_ReleaseStrong;
            DynObj *pdo = DoCasterSelect<T,DynObj,DoIsTypeA<T,DynObj>::v>::Cast(pt,pdt);
            if( !pdo ) goto Failed_ReleaseStrong;
            if( !pdorti->TrackDynObj(pdo,this,true,pdt) )
                goto Failed_ReleaseStrong;
            m_flags |= hasDoRef;
            m_pdo = pdo;
            m_pt = pt;
        }
        
        return true;

Failed_ReleaseStrong:
        // If we were not trying strong ref now, then do so.
        if( !try_strong_ref && InternalAssign(pt,2) )
            return true;

        // If failed after acquiring strong ref, we must release it
        if( prci ) {
            prci->DecRef();
            m_pt = NULL;
        }
        m_flags &= ~hasStrongRef;
        DO_ASSERT_MSG( !(m_flags&(hasDoRef|hasWeakRef|hasStrongRef)), "All ref flags should be cleared now" );
        return false;
    }

    void InternalRelease(){
        if( m_pt ){
            DynObjType *pdt = ::doGetType( (typename VBaseSelect<T>::type*)m_pt );
            
            if( m_flags&hasDoRef ){
                DortInternalI *pdorti = (DortInternalI*)doGetObj( &DORT, DORTINTERNALI_TYPE_ID ); 
                if( pdorti ){
                    DO_ASSERT_MSG( m_pdo, "Should have store DynObj*" );
                    m_flags &= ~hasDoRef;
                    bool r = pdorti->TrackDynObj( m_pdo, this, false );
                    DO_ASSERT_MSG(r,"Should succeed in removing tracker");
                }
                if( !pdorti )
                    DO_LOG_ERR(DOERR_CANT_FIND_TYPE,"DynObjPtr::InternalRelease - Failed finding interface DortInternalI or DynObj");
            }
            if( m_flags&hasWeakRef ){
                // So it must be a Notifier ref
                DO_ASSERT_MSG(m_pni,"Should have stored NotifierI*");
                m_flags &= ~hasWeakRef;
                bool r = m_pni->RemoveNotifiable(this,NOT_EVT_DTOR);
                DO_ASSERT_MSG(r,"Should succeed removing NotifiableI");
            }
            
            if( m_flags&hasStrongRef ){
                // Release ref count - may destroy object
                RefCountI *prci = DoCasterSelect<T,RefCountI,DoIsTypeA<T,RefCountI>::v>::Cast(m_pt,pdt);
                if( prci ){
                    prci->DecRef();
                    m_flags &= ~hasStrongRef;
                }
                else
                    DO_LOG_ERR(DOERR_CANT_FIND_TYPE,"DynObjPtr::InternalRelease - Failed finding interface RefCountI");
            }
            if( m_flags&(hasDoRef|hasWeakRef|hasStrongRef) )
                DO_LOG_ERR( DOERR_CANT_FIND_TYPE, "DynObjPtr::InternalRelease - All ref flags should be cleared now" );
            m_pni = NULL;
            m_pt = NULL;
        }
    }

    // Tracked object releases our pointer on it
    virtual bool docall OnNotify( NotifierI *pni, int evt, NotifDataI *pnd ){
        bool is_ok_caller = false;
        if( evt==NOT_EVT_DTOR ){
            DO_ASSERT_MSG( m_flags&hasWeakRef && pni==m_pni, "Should match weak ref (NotrifierI) in OnNotify" );
            if( pni==m_pni )
                is_ok_caller = true;
        }
        else if( evt==NOT_EVT_ON_DYNOBJ_DESTROY ){
            NotifDataWithPtr *pndwp = do_cast<NotifDataWithPtr*>(pnd);
            if( pndwp ){
                DO_ASSERT_MSG( m_flags&hasDoRef && pndwp->m_pdi==m_pdo, "Should match weak ref (DynObj) in OnNotify" );
                if( pndwp->m_pdi==m_pdo )
                    is_ok_caller = true;
            }
        }
        DO_ASSERT_MSG(m_pt,"Should have tracked object");
        DO_ASSERT_MSG(is_ok_caller,"Should have OK caller");
        if( !is_ok_caller )
            return false;

        m_pt = NULL;
        m_flags &= ~(hasDoRef|hasWeakRef|hasStrongRef);
        return true;
    }

    char m_flags;
    bool m_flag_unused2;
    bool m_flag_unused1;
    bool m_flag_unused;     // For derived class
    
    T* m_pt;
    union {
        NotifierI *m_pni;
        DynObj *m_pdo;
    };
    //short m_off_begin; // Track whole mem area of object
    //short m_off_end; 
};

#endif // DYNOBJPTR_HPP

---