DynTmp.hh

Go to the documentation of this file.

#ifndef NO_PTR_DYNTMP_H
#define NO_PTR_DYNTMP_H

#include "nullness.hh"  // use
#include "RRefUsage.hh" // contain
#include "Deleter.hh"   // inherit
#include "DynObjKey.hh" // use
#include "NoPtrFwd.hh"  // use

namespace NoPtr
{
    template <typename ObjType>
    class DynTmp // inherit so EBO (empty base optimization) possible
                 // and privately since not for polymorphism:
        : private NoPtrImpl::Deleter<ObjType>
    {
        public:
            DynTmp(const DynTmp& dynmobj) throw()
                : _obj(dynmobj._obj)
            {
                dynmobj._obj = NullPtr;
                dynmobj._rrefUsage.moveTo(_rrefUsage);
            }
            template <typename ObjType2>
            DynTmp(const DynTmp<ObjType2>& dynmobj) throw()
                : _obj(dynmobj._obj)
            {
                dynmobj._obj = NullPtr;
                dynmobj._rrefUsage.moveTo(_rrefUsage);
            }
           ~DynTmp()
            {
                destroy(_obj);
                _rrefUsage.destroy();
            }
           
            DynTmp(ObjType* ptr) throw(): _obj(ptr) { }
            
            ObjType* release() throw()
            {
                _rrefUsage.destroy();
                ObjType* const tmp = _obj;
                _obj = NullPtr;
                return tmp;
            }
            
        public: // only for DynObj
                
            // Create from the DAO held by DynObj
            DynTmp(ObjType* ptr, NoPtrImpl::RRefUsageForOwner& rrefUsage,
                     NoPtrImpl::DynObjKey<ObjType>) throw()
                : _obj(ptr) {rrefUsage.moveTo(_rrefUsage);}
        
            /* Deliver the DAO held to a DynObj. The required key
               garantees that this method can be called only by a
               DynObj, even though the method is public. This avoids
               having to make DynObj a friend.
               */
            template <typename ObjType2>
            void deliver( ObjType2*& obj, 
                     NoPtrImpl::RRefUsageForOwner& rrefUsage,
                     NoPtrImpl::DynObjKey<ObjType2> ) const throw()
            {
                obj  = _obj;
                _obj = NullPtr;
                _rrefUsage.moveTo(rrefUsage);
            }
            
        private:
            template <typename> friend class DynTmp;
            
        private:
            // data mutable since DynTmp has no logical state per se
            mutable ObjType* _obj;
            mutable NoPtrImpl::RRefUsageForOwner _rrefUsage;
    };

    template <typename ObjType>
    DynTmp<ObjType> 
    makeDynTmp(ObjType* const newDAO) {return newDAO;}
    
    template <typename ObjType>
    DynTmp<ObjType> 
    makeDynObj(ObjType* const newDAO) {return newDAO;}
    
} // namespace

#endif // NO_PTR_DYNTMP_H    

---