DynObj.hh

Go to the documentation of this file.

#ifndef NO_PTR_DYNOBJ_H
#define NO_PTR_DYNOBJ_H

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

/* Define specializations of std::swap, and declare auto_ptr
   so don't need to include its full header. Note that defining 
   specializations in the std namespace is considered appropriate
   (what's not is to \em add new members to the namespace).
   */
namespace std
{
    // forward declare auto_ptr so we don't have to include 
    // the whole <memory> file; user will be including it anyways.
    template<typename TT> class auto_ptr;
    
    // disregard current Standard: define swap for simple DynObj
    template <typename ObjType>
    inline void 
    swap(NoPtr::DynObj<ObjType>& lhs, 
         NoPtr::DynObj<ObjType>& rhs)
    {
        lhs.swap(rhs);
    }
        
    // disregard current Standard: define swap for value DynObj
    template <typename ObjType>
    inline void 
    swap(NoPtr::DynObj<ObjType, NoPtr::InValueContainer>& lhs, 
         NoPtr::DynObj<ObjType, NoPtr::InValueContainer>& rhs)
    {
        lhs.swap(rhs);
    }
        
    // disregard current Standard: define swap for other value DynObj
    template <typename ObjType>
    inline void 
    swap(NoPtr::DynObj<ObjType, NoPtr::InValueContainerOpt1>& lhs, 
         NoPtr::DynObj<ObjType, NoPtr::InValueContainerOpt1>& rhs)
    {
        lhs.swap(rhs);
    }
        
    // disregard current Standard: define swap for other value DynObj
    template <typename ObjType>
    inline void 
    swap(NoPtr::DynObj<ObjType, NoPtr::InValueContainerOpt2>& lhs, 
         NoPtr::DynObj<ObjType, NoPtr::InValueContainerOpt2>& rhs)
    {
        lhs.swap(rhs);
    }
        
    /* \todo Specialize iter_swap for DynObj: 
    template<typename ForwardIter1, typename ForwardIter2>
    inline void
    iter_swap(ForwardIter1 fi1, ForwardIter2 fi2)
    {
        fi1->swap(*fi2);
    }*/

}

namespace NoPtr
{
    template <typename TT, class Context>
    inline bool 
    isNull(const DynObj<TT,Context>& p) {return p.isNull();}

    template <typename TT, class Context>
    inline bool 
    isNotNull(const DynObj<TT,Context>& p) {return p.isNotNull();}

    template <typename ObjType, class Context>
    class DynObj // inherit so EBO (empty base optimization) possible
                 // and privately since not for polymorphism 
        : private NoPtrImpl::Deleter<ObjType>, 
          private Context
    {
        private:
            template <typename, class> friend class DynObj;
            template <typename> friend class DynTmp;
            
        public:
            typedef ObjType ObjectType;
            typedef DynObj<ObjType,NoPtr::InValueContainer> 
                    InValueContainer;
            typedef DynObj<ObjType,NoPtr::InValueContainerOpt1> 
                    InValueContainerOpt1;
            typedef DynObj<ObjType,NoPtr::InValueContainerOpt2> 
                    InValueContainerOpt2;

        public:

            DynObj() throw(): _obj(NullPtr) {}
            explicit DynObj(ObjType* ptr) throw(): _obj(ptr) {}
            
            template <typename ObjType2>
            explicit DynObj(std::auto_ptr<ObjType2>& aptr) throw()
                : _obj( aptr.release() ) {}
            template <typename ObjType2>
            DynObj(const DynTmp<ObjType2>& mobj) throw()
            { 
                mobj.deliver( _obj, _rrefUsage, 
                              NoPtrImpl::DynObjKey<ObjType>() );
            }
            
           ~DynObj()
            {
                if (soleOwner()) 
                {
                    destroy(_obj);
                    _rrefUsage.destroy();
                }
            }
            
            // If TEST_ALL_INSTANTIATE is defined we can't define copy 
            // since it is prevented by default via a compilation error
            #ifndef TEST_ALL_INSTANTIATE
            /*  Copy a dynobj. This is only provided for use by 
                copyable contexts such as STL containers. I.e. it compiles 
                only if the second template parameter is InValueContainer 
                (or InValueContainerOpt*). You should never have to use this 
                yourself. */
            DynObj(const DynObj& rhs) // only for non-default context
                : NoPtrImpl::Deleter<ObjType>(), Context(rhs), _obj(rhs._obj),
                  _rrefUsage(rhs._rrefUsage) 
            {
                Context::checkCopyable();
                // do NOT do rhs._obj = NullPtr;
                // since when copyable rhs is const
            }
            #endif
            
            
            void acquire(ObjType* ptr) 
            {
                assert(ptr != _obj); // would mean bug!
                assert(soleOwner());
                destroy(_obj); // MUST NOT throw
                _rrefUsage.reset();
                _obj = ptr;
            }
            template <typename ObjType2>
            void acquire(std::auto_ptr<ObjType2>& aptr)
            {
                acquire(aptr.release());
            }

            template <typename ObjType2, class Context2>
            void acquire(DynObj<ObjType2,Context2>& rhs)
            {
                assert(rhs._obj != _obj); // would mean bug!
                assert(soleOwner());
                destroy(_obj); // MUST NOT throw
                _rrefUsage.reset();
                
                assert(rhs.soleOwner());
                _obj = rhs._obj;
                rhs._obj = NullPtr; 
                rhs._rrefUsage.moveTo(_rrefUsage);
                // leave rhs._obj in registry
            }
            template <typename ObjType2>
            void acquire(const DynTmp<ObjType2>& mobj)
            {
                assert(soleOwner()); 
                reset();
                mobj.deliver( _obj, _rrefUsage, 
                              NoPtrImpl::DynObjKey<ObjType>() );
            }
            
            
            void reset() 
            {
                assert(soleOwner());
                destroy(_obj); // MUST NOT throw
                _rrefUsage.reset();
                _obj = NullPtr;
            }
            
            void swap(DynObj& rhs) throw() 
            {
                std::swap(_obj, rhs._obj);
                _rrefUsage.swap(rhs._rrefUsage);
                Context::swap(rhs);
            }
                
            ObjType* release() throw()
            {
                assert(soleOwner()); 
                _rrefUsage.reset();
                ObjType* const tmp = _obj;
                _obj = NullPtr;
                return tmp;
            }

            DynTmp<ObjType> moveToTmp() throw()
            {
                assert(soleOwner()); 
                ObjType* const tmp = _obj;
                _obj = NullPtr;
                return DynTmp<ObjType>( tmp, _rrefUsage, 
                                        NoPtrImpl::DynObjKey<ObjType>() );
            }
            DynTmp<ObjType> giveAway() throw() {return moveToTmp();}
            
            
            
            
            bool isNull() const throw() 
            {
                assert(soleOwner()); 
                return _obj == NullPtr;
            }
            bool isNotNull() const throw() 
            {
                assert(soleOwner()); 
                return _obj != NullPtr;
            }
            
            ObjType* getPtr() const throw() 
            { 
                assert(soleOwner()); 
                return _obj; 
            }
            
            
            
            ObjType& operator()() const
            {
                return *(operator->());
            }
            
            ObjType& operator*() const
            {
                return *(operator->());
            }
            
            template <typename ObjType2>
            void operator=(const DynTmp<ObjType2>& mobj)
            {
                acquire(mobj);
            }                
            template <typename ObjType2, class Context2>
            bool operator<(const DynObj<ObjType2,Context2>& rhs) const throw()
            {
                if (_obj && rhs._obj) // both non-null:
                    return (*_obj) < *(rhs._obj);
                
                // at least one null, compare pointers
                if (_obj == NullPtr) return true;
                // else rhs must be null, so result is false:
                assert(rhs._obj == NullPtr);
                return false;
            }
            template <typename ObjType2, class Context2>
            bool operator==(const DynObj<ObjType2,Context2>& rhs) const throw()
            {
                if (_obj && rhs._obj) // compare DAO's
                    return (_obj == rhs._obj) || ((*_obj) == *(rhs._obj));
                
                // at least one is null, so compare pointers
                return _obj == rhs._obj;
            }
            template <typename ObjType2, class Context2>
            bool operator!=(const DynObj<ObjType2,Context2>& rhs) const throw()
            {
                return !(*this == rhs);
            }
            
            #include "opConstWarningOff.hpp"
            operator const DynObj<const ObjType,Context>&() const throw()
            {
                typedef DynObj<const ObjType,Context> DynConstObj;
                return * static_cast<const DynConstObj*>(
                     static_cast<const void*>(this)
                );
            }
            #include "opConstWarningOn.hpp"
            
            // If TEST_ALL_INSTANTIATE is defined we can't define assignment
            // since it is prevented by default via a compilation error
            #ifndef TEST_ALL_INSTANTIATE
            
            /*  Copy from a dynobj. This is only provided for use by 
                value-based containers such as STL containers. It compiles 
                only if the second template parameter is InValueContainer 
                (or InValueContainerOpt*). You should never have to use this 
                yourself. 
                
                \todo Test this rigorously since complex function; especially
                      if _rrefusage has or hasn't been initialized
                */
            DynObj& operator=(const DynObj& rhs)
            {
                // we know that if _obj == rhs._obj then *this is 
                // either rhs or both are null, then no need to copy
                if (_obj == rhs._obj) return *this;
                
                // ok, valid copy:
                
                Context::checkCopyable(); // compile time check
                if (soleOwner()) 
                // only one owning _obj so destroy it; otherwise, 
                // one of other owners will do it;
                {
                    destroy(_obj);
                    _rrefUsage.reset();
                }
                
                _obj = rhs._obj;
                // do NOT do rhs._obj = NullPtr;
                // since when copyable rhs is const
                _rrefUsage = rhs._rrefUsage;
                Context::operator=(rhs);
                return *this;
            }
            #endif // TEST_ALL_INSTANTIATE
                
        public: // only to RRef
                
            /* Public just to avoid more friends. From user point of view,
               this method is private, i.e. don't use it. This is how DynObj 
               allows RRef to get data that will allow RRef to know when 
               DynObj has destroyed DAO. 
               */
            void getRRefUsage(NoPtrImpl::RRefUsageForUser& rrefUsage) const
            {
                _rrefUsage.create();
                rrefUsage.shareFrom(_rrefUsage);
            }
            
        private:
            /*  The traditional indirection operator to access members
                of the ObjType instance referred to by this RRef. E.g.
                use it as dynobj->method() to access Foo::method() for 
                a dynobj of type DynObj<Foo>.
                */
            ObjType* operator->() const
            {
                assert(soleOwner()); 
                assert(NoPtr::isNotNull(_obj));
                return _obj;
            }
            
        private:
            ObjType* _obj; 
            mutable NoPtrImpl::RRefUsageForOwner _rrefUsage; 
    };
                
} // namespace

#endif // NO_PTR_DYNOBJ_H    

---