---

OwnedPtr.hh

Go to the documentation of this file.

#ifndef MANGO_OWNED_PTR_H
#define MANGO_OWNED_PTR_H

#include <memory>          // auto_ptr
#include <stdexcept>       // throws

#include "nullness.hh"     // use
#include "ObjSharing.hh"   // use
#include "ValidityChecker.hh" // use
#include "CheckedPtr.hh"   // use
#include "Ownership.hh"    // use
#include "BLinkableFWD.hh" // use
#include "BLinkFWD.hh"     // use
#include "OwnedFWD.hh"     // use

namespace MangoPtr
{
    // Overload of isNull(T*) for Owned pointers
    template <typename T, OwnershipType oshiptype>
    inline bool 
    isNull(const Owned<T,oshiptype>& p) {return p.isNull();}
    
    // Overload of isNotNull(T*) for Owned pointers
    template <typename T, OwnershipType oshiptype>
    inline bool 
    isNotNull(const Owned<T,oshiptype>& p) {return p.isNotNull();}

    template <typename OType, OwnershipType oshiptype>
    class Owned<OType*, oshiptype>
        : protected BLinkable<ForOwnedBy::Wrapper>
    {
        protected:
            typedef OType* PType;
            template <typename O2Type, OwnershipType oshiptype2> 
                    friend class Owned;

        public:
            typedef OType ObjectType;



            Owned(): optr(NullPtr), deleteObj(&Owned::callDelete) {}      
            // When the whole template is instantiated, owner 
            // copy is only possible with oshiptype=OShared.
            #ifndef MANGO_ALL_TEMPLATE_INSTANTIATE
            inline Owned(const Owned&);
            template <typename O2Type> inline 
            Owned(const Owned<O2Type, oshiptype>&);
            #endif
            explicit Owned(OType*);
            template <typename O2Type> explicit inline 
            Owned(std::auto_ptr<O2Type>&);
            template <typename O2Type> explicit inline 
            Owned(Ownership<O2Type, oshiptype>);
            inline ~Owned();

        public: 

            inline void swap(Owned& rhs);
            inline PType release();
            inline void reset() {resetToDefault(); nullify(optr);}
            inline Ownership<PType, oshiptype> giveOwnership();
            // When the whole template is instantiated, owner 
            // assignment is only possible with oshiptype=OShared.
            #ifndef MANGO_ALL_TEMPLATE_INSTANTIATE
            inline Owned& operator=(const Owned& rhs) {return assignFrom(rhs);}
            template <typename O2Type> 
            inline Owned& 
            operator=(const Owned<O2Type, oshiptype>& rhs) {return assignFrom(rhs);}
            #endif 

            inline void takeOwnership(OType* p);
            template <typename O2Type> inline void 
            takeOwnership(std::auto_ptr<O2Type>&);
            template <typename O2Type> inline void 
            takeOwnership(Ownership<O2Type, oshiptype>);

        public: 

            inline PType cloneObjNew() const;
            inline PType shareUsage(ValidityChecker&) const;
            #include "opConstWarningOff.pp"
            inline operator const Owned<const OType*, oshiptype>&() const;
            #include "opConstWarningOn.pp"

        public: 
            // /\name Accessors
            // @{
            inline bool isNotNull() const { return sharing.isValid((void*)optr); }
            inline bool isNull() const { return ! isNotNull(); }
            size_t getCountUser() const {return sharing.getCountUser();}
            size_t getCountOwned() const {return sharing.getCountOwned();}
            bool owns(PType rhs) const {return MangoPtr::isNotNull(rhs) && rhs==optr;}
            template <typename O2Type>
            bool owns(const BLink<O2Type>& rhs) const {return owns(rhs());}
            CheckedPtr<OType> operator()() const {return isNotNull() ? optr : NullPtr;}
            OType* ptr() const {return isNotNull() ? optr : NullPtr;}
            bool operator==(const Owned& rhs) const {return optr == rhs.optr;}
            bool operator!=(const Owned& rhs) const {return optr != rhs.optr;}
            bool operator<(const Owned& rhs)  const {return optr <  rhs.optr;}
            // @}

        private: // methods
            inline void resetToDefault();
            template <typename O2Type> 
            inline Owned& assignFrom(const Owned<O2Type, oshiptype>&);
            inline void callDelete() {delete optr;}
            
            
        private: // data
            PType optr; 
            
            mutable ObjSharing<oshiptype> sharing; 
        
            typedef void (Owned::*DeleteFn)();
            const DeleteFn deleteObj; 
    };

    #ifndef MANGO_ALL_TEMPLATE_INSTANTIATE

    template <typename OType, OwnershipType oshiptype>
    inline 
    Owned<OType*, oshiptype>::Owned(const Owned& owner)
        : optr(owner()), sharing(owner.sharing((void*)optr)), 
          deleteObj(&Owned::callDelete)
    {
        assert(MangoPtr::isNull(optr) == isNull());
    }

    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline 
    Owned<OType*, oshiptype>::Owned(const Owned<O2Type,oshiptype>& owner)
        : optr(owner()), sharing(owner.sharing((void*)optr)), 
          deleteObj(&Owned::callDelete)
    {
        assert(MangoPtr::isNull(optr) == isNull());
    }
    #endif // MANGO_ALL_TEMPLATE_INSTANTIATE
    
    template <typename OType, OwnershipType oshiptype>
    inline 
    Owned<OType*, oshiptype>::Owned(OType* p)
        : optr(p), deleteObj(&Owned::callDelete)
        // sharing.pointer set only if optr used
    {
    }

    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline 
    Owned<OType*, oshiptype>::Owned(std::auto_ptr<O2Type>& ap)
        : optr(ap.release()), deleteObj(&Owned::callDelete)
        // sharing.pointer set only if optr used
    {
    }

    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline 
    Owned<OType*, oshiptype>::Owned(Ownership<O2Type, oshiptype> os)
        : optr(NullPtr), deleteObj(&Owned::callDelete)
    {
        sharing.swap(os.owner.sharing);
        optr = os.owner();
        os.owner.optr = NullPtr;
        assert(MangoPtr::isNull(optr) == isNull());
        assert(os.owner.isNull());
    }

    template <typename OType, OwnershipType oshiptype>
    inline 
    Owned<OType*, oshiptype>::~Owned() 
    {
        if (sharing.destructNeedsDelete((void*)optr))
        {
            (this->*deleteObj)();
            sharing.invalidateUsage();
        }
    }
        
    template <typename OType, OwnershipType oshiptype>
    inline void 
    Owned<OType*, oshiptype>::resetToDefault()
    {
        if (sharing.destructNeedsDelete((void*)optr) )
        {
            (this->*deleteObj)();
            sharing.invalidateUsage();
        }
        // unlink from remaining sharers
        sharing.unlinkNew();
    }

    template <typename OType, OwnershipType oshiptype>
    inline void 
    Owned<OType*, oshiptype>::takeOwnership(OType* p)
    {
        resetToDefault();
        optr = p;
    }

    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline void 
    Owned<OType*, oshiptype>::takeOwnership(std::auto_ptr<O2Type>& ap)
    {
        resetToDefault();
        optr = ap.release();
    }

    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline void 
    Owned<OType*, oshiptype>::takeOwnership(Ownership<O2Type, oshiptype> os)
    {
        resetToDefault();
        sharing.swap(os.owner.sharing);
        optr = os.owner();
        nullify(os.owner.optr);
        assert(MangoPtr::isNull(optr) == isNull());
    }

    /*
        Make this owner equal to the one on the \a rhs.
        Since two owners can't refer to the same pointee,
        this owner will contain a clone of the pointee 
        owned by \a rhs.
    */
    template <typename OType, OwnershipType oshiptype>
    template <typename O2Type>
    inline Owned<OType*, oshiptype>&
    Owned<OType*, oshiptype>::assignFrom(const Owned<O2Type, oshiptype>& rhs)
    {
        resetToDefault();
        optr = rhs();
        sharing = rhs.sharing((void*)optr);
        return *this;
    }

    template <typename OType, OwnershipType oshiptype>
    inline Ownership<OType*, oshiptype> 
    Owned<OType*, oshiptype>::giveOwnership() 
    {
        return Ownership<OType*, oshiptype>(*this);
    }

    template <typename OType, OwnershipType oshiptype>
    inline void 
    Owned<OType*, oshiptype>::swap(Owned& rhs) 
    {
        std::swap(optr, rhs.optr);
        sharing.swap(rhs.sharing);
    }

    template <typename OType, OwnershipType oshiptype>
    inline OType* 
    Owned<OType*, oshiptype>::cloneObjNew() 
    const
    { 
        return isNotNull() ? new OType(*optr) : NullPtr;
    }

    template <typename OType, OwnershipType oshiptype>
    inline OType* 
    Owned<OType*, oshiptype>::release() 
    {
        // make sure all users know they can't use it anymore
        sharing.invalidateUsage();
        // and unlink us from other owners and users
        sharing.unlinkNew();
        PType tmp = optr;
        nullify(optr);
        return tmp;
    }

    template <typename OType, OwnershipType oshiptype>
    inline 
    Owned<OType*, oshiptype>::operator const Owned<const OType*, oshiptype>&() 
    const 
    {
        return * static_cast<const Owned<const OType*, oshiptype>*>(
                     static_cast<const void*>(this)
                 );
    }
    
    template <typename OType, OwnershipType oshiptype>
    inline OType* 
    Owned<OType*, oshiptype>::shareUsage(ValidityChecker& val) 
    const
    {
        val = sharing((void*)optr).usage(); 
        assert(val.isShared());
        assert(val.isValid() == MangoPtr::isNotNull(*this));
        return (*this)();
    }
              
} // namespace

#endif // MANGO_OWNED_PTR_H

---