ScopedDynObj.hpp

#ifndef SCOPEDDYNOBJ_HPP
#define SCOPEDDYNOBJ_HPP

#include "DynObjPtr.hpp" 
#include "DoNew.h"

#if DO_USE_RUNTIME==1
    #include "DoNew.h"
#endif 

// LocalDynObj and ScopedDynObj are the same
#define LocalDynObj ScopedDynObj 

template<class T>
struct ScopedDynObj : public DynObjPtr<T> {
    explicit ScopedDynObj( T* pt=NULL ) { 
        this->m_flag_unused = false;
        if( !pt ){
            pt = do_new<T>( (DynI*)NULL );
            if( !pt ) return;
        }
        DoAssign( pt );
    } 
    
    template<class A>
    explicit ScopedDynObj( A arg ) { 
        this->m_flag_unused = false;
        T* pt = do_new<T>( arg );
        if( !pt ) return;
        DoAssign( pt );
    } 

#if DO_USE_RUNTIME==1
    template<class A>
    explicit ScopedDynObj( const char* lib_name, A arg ) { 
        this->m_flag_unused = false;
        T* pt = do_new<T>( lib_name, arg );
        if( !pt ) return;
        DoAssign( pt );
    } 
#endif 
    
    ~ScopedDynObj(){
        if( !this->m_pt ) return;
        // We own the object, clear before base class dtor
        ::doReleaseDestroy(this->m_pt);
        this->m_pt = NULL;
    }

    T& operator () () { return *this->m_pt; } 

   bool IsOk(){ return this->m_pt!=NULL; } 
    
protected:
    void DoAssign( T* pt ){
        if( !pt ) return;
        // Try assigning safely
        if( !this->InternalAssign(pt,false) ){
            // Failed, not using DynObjPtr truly, go around it
            this->m_flag_unused = true;
            this->m_pt = pt;  
            // It is only an unsafe instance if we hold a plugin object. 
            // Main objects cannot be unloaded suddenly.'
            if( ::doIsMainObject(pt)<=0 )
                DO_LOG1( "ScopedDynObj - Ownership of plugin object without weak ref: %p", pt );
        }
    }
    
private:
    // Hide base class functions
    ScopedDynObj& operator = (T* pt){
        DO_ASSERT_MSG(0,"Should not assign to ScopedDynObj");
        return *this;
    }
    ScopedDynObj& operator = (const DynObjPtr<T>& dop){
        DO_ASSERT_MSG(0,"Should not assign to ScopedDynObj");
        return operator = ((T*)dop);
    }
}; 

#endif // SCOPEDDYNOBJ_HPP

---