DynObjHolder.hpp

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder


#ifndef DYNOBJ_HOLDER_HPP
#define DYNOBJ_HOLDER_HPP

// DynObjHolder - temporary hold DynObj and release in destructor
// NOTE:
// This "all-purpose" class has been replaced by more lightweight classes:
//  ScopedDynObj<T>
//  DynWeakRef<T>
//  RefCntDynObjPtr<T>

#include "DoBase.hpp"
#ifndef DOH_SKIP_NEW_ABILITY
    #include "DoNew.h"
#endif

// Deduction
#if DO_USE_RUNTIME==1 && defined(DO_MAIN)
    // DoRunTimeC uses Notifier
    #ifndef DO_USE_NOTIFIER
        #define DO_USE_NOTIFIER 1
    #endif
#endif

#if DO_USE_NOTIFIER==1
    #include "DoNotifier.hpp"
#endif

enum HoldMode { hmOwn=1, hmShared, hmStatic, hmWeakRef, hmAutoOwn, hmAutoNoOwn, hmAuto };
    

template <class T>
struct DynObjHolder {
#if DO_USE_RUNTIME==1 && !defined(DOH_SKIP_NEW_ABILITY)

    DynObjHolder( ) : m_pdo(0) { 
        m_pdo = do_new<T>( );
        m_mode = hmAutoOwn;    // We created it so we own it
    }
    
    template<class A>
    DynObjHolder( A arg ) { 
        m_pdo = do_new<T>( arg );
        m_mode = hmAutoOwn;    // We created it so we own it
    }
#endif // DO_USE_RUNTIME==1 && !DOH_SKIP_NEW_ABILITY

    DynObjHolder( T *pdo, HoldMode mode ) : m_pdo(NULL), m_mode(mode) {
        Assign( pdo, mode );
    }
    
    DynObjHolder& Assign( T *pdo, HoldMode mode ){
        // Detect case where we don't have to re-assign
        if( pdo && (m_pdo==pdo 
#if DO_USE_NOTIFIER==1
            || (m_mode==hmWeakRef && m_pwr && m_pwr->Get()==pdo) 
#endif            
            ))
            return *this;
            
        Release( );
        if( !pdo ){
            // Work with old mode
            if( m_mode!=hmWeakRef ) m_pdo = NULL;
#if DO_USE_NOTIFIER==1
            else if(m_pwr) m_pwr->Reset(NULL);
#endif            
            // Work with new mode
            if( m_mode==hmWeakRef && mode!=hmWeakRef ){
#if DO_USE_NOTIFIER==1
                delete m_pwr;
                m_pwr = NULL;
#endif
            }
            m_mode = mode;  // Set the mode, it's a hint for the future
            return *this;
        }

        // With auto-mode, sort it either to AutoOwn or AutoNoOwn
        if( mode==hmAuto ){
            if( doIsStatic(pdo) )
                mode = hmStatic;
            else if( pdo->CanBeA(NOTIFIERI_TYPE_ID) )
                mode = hmWeakRef;
            else 
                mode = hmAutoOwn;
        }
        
        HoldMode old_mode = m_mode;
#if DO_USE_NOTIFIER==1
        // Store in case of delete / reuse
        WeakRef<T> *old_pwr = old_mode==hmWeakRef ? m_pwr : NULL; 
#endif
        // Assume this will work for now
        m_mode = mode;
        m_pdo = pdo;
        if( mode==hmOwn || mode==hmAutoOwn || mode==hmShared ){
            // Need DynObj derived type
            if( !pdo->CanBeA(DYNOBJ_TYPE_ID) ){
                DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, Request to store owning reference, but no DynObj interface available", pdo );
                goto Assign_Return_Failed;
            }
#if DO_USE_DYNSHARED==1
            if( mode==hmShared || (mode==hmAutoOwn && pdo->CanBeA(DYNSHAREDI_TYPE_ID)) ){
                // Use shared ownership, add ref
                m_mode = hmShared;
                DynSharedI *psi = do_cast<DynSharedI*>(pdo);
                if( psi )
                    psi->doAddRef();
                else{
                    DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, Request to store hold as shared object, no DynSharedI available", pdo );
                    goto Assign_Return_Failed;
                }
            }
            else
#endif // DO_USE_DYNSHARED==1
            {
                // Single-point ownership
                m_mode = hmOwn;
                if( pdo->CanBeA(DYNSHAREDI_TYPE_ID) || doIsStatic(pdo) ){
                    DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, Request for single point ownership, but object is shared (or static), no DynSharedI available", pdo );
                    goto Assign_Return_Failed;
                }
            }
        }
        
        else if( mode==hmStatic ){
            if( !doIsStatic(pdo) ){
                DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, Request for static holding, but object type is not static", pdo );
                goto Assign_Return_Failed;
            }
        }

        else if( mode==hmWeakRef || mode==hmAutoNoOwn ){
            if( mode==hmAutoNoOwn && doIsStatic(pdo) ){
                m_mode = hmStatic;
            }
            else {
#if DO_USE_NOTIFIER==1
                // Must make WeakRef
                m_mode = hmWeakRef;
                if( !pdo->CanBeA(NOTIFIERI_TYPE_ID) ){
                    DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, hmWeakRef - Object does not support NotifierI", pdo );
                    goto Assign_Return_Failed;
                }
                // Assign new Weak ref if NULL or or old pointer is not WeakRef
                if( old_pwr ){
                    m_pwr = old_pwr;
                    m_pwr->Reset(pdo);
                }
                else
                    m_pwr = new WeakRef<T>(pdo);
#else
                DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, hmWeakRef - Weak ref not supported in build", pdo );
                goto Assign_Return_Failed;
#endif        
            }
        }
        else{
            DO_LOG_ERR1( DOERR_CLASS_DYNOBJHOLDER, "DynObjHolder<T>, Unknown holding mode", mode );
            goto Assign_Return_Failed;
        }

        // Success
        return *this;
        
Assign_Return_Failed:
#if DO_USE_NOTIFIER==1
        if( m_mode!=hmWeakRef ){
            m_pdo = NULL;
            delete old_pwr;
        }
        else{ 
            m_pwr = old_pwr;
            if(m_pwr) m_pwr->Reset(NULL);
        }
#else
        m_pdo = NULL;
#endif
        return *this;
    }

    ~DynObjHolder(){ 
        Release( );
#if DO_USE_NOTIFIER==1
        if( m_mode==hmWeakRef )
            delete m_pwr;
#endif
    }
     
    T *Get() const { 
        if( m_mode!=hmWeakRef )
            return m_pdo; 
        else{
#if DO_USE_NOTIFIER==1
            return m_pwr ? m_pwr->Get() : NULL;
#else
            assert(0);   // Not supported 
            return NULL;
#endif        
        }
     }
    
     T &operator()() const { return *Get(); }
     T& operator*() const { return *Get(); }
     
     T *operator->() const { return Get(); }
     
     bool operator !() const { return !IsOk(); }
         
     DynObjHolder& operator = (T *pdo){
        return Assign( pdo, m_mode );
     }
     
     bool IsOk() const { 
        if( m_mode!=hmWeakRef )
            return m_pdo!=NULL; 
        else{
#if DO_USE_NOTIFIER==1
            return m_pwr && m_pwr->Get()!=NULL;
#else
            return false;
#endif        
        }
    }

    void Release() { 
        switch(m_mode){
            case hmOwn:
            case hmShared:
            case hmAutoOwn: doReleaseDestroy( (DynObj*)m_pdo ); m_pdo=NULL; break;
            case hmStatic: m_pdo=NULL; break; 
            case hmWeakRef:
#if DO_USE_NOTIFIER==1
                m_pwr->Reset( NULL );
#endif        
                break;
        }
    }
    
protected:
    union {
        T *m_pdo;
#if DO_USE_NOTIFIER==1
        WeakRef<T> *m_pwr;
#endif        
    };
    HoldMode m_mode;
};

#define DOH DynObjHolder // Convenience macro

#ifdef TYPEOF_H
    #undef TYPE_REG_FILE
    #define TYPE_REG_FILE 500
    TYPE_REG_T1(DynObjHolder)
#endif

#endif // DYNOBJ_HOLDER_HPP

---