---

OwnedCntr.hh

Go to the documentation of this file.

#ifndef MANGO_OWNED_CONTAINER_H
#define MANGO_OWNED_CONTAINER_H

#include "nullness.hh"        // use
#include "ValidityOwner.hh"   // use
#include "ValidityChecker.hh" // use
#include "CntrCleaner.hh"     // use
#include "CntrClonerFWD.hh"   // use
#include "BLinkableFWD.hh"    // inherit
#include "Ownership.hh"       // use
#include "OwnedFWD.hh"        // use

namespace MangoPtr
{    
    template <typename CntrType, OwnershipType oshiptype>
    class Owned: protected BLinkable<ForOwnedBy::Wrapper>
    {
        public:
            typedef CntrType OwnedType;



            Owned(): cleanerUpper(&Owned::doCleanUp) {}      
            inline explicit Owned(CntrType&);
            template <typename O2Type> explicit inline 
            Owned(Ownership<O2Type, oshiptype>);
            inline ~Owned();

        public: 

            inline void swap(Owned&);
            inline void swap(CntrType&);
            inline void clear();
            inline void unlink() const;
            inline void reset();
            
            inline Ownership<CntrType, oshiptype> transfer();
            inline void takeOwnership(CntrType&);
            template <typename O2Type> 
            inline void takeOwnership(Ownership<O2Type, oshiptype>);

        public: 

            inline void cloneObjNew(CntrType&) const;
            inline CntrType* shareUsage(ValidityChecker&) const;
            CntrType& cntr() {return ocntr;}
            const CntrType& cntr() const {return ocntr;}
            CntrType* operator()() {return &ocntr;}
            const CntrType* operator()() const {return &ocntr;}

        private: // data
            mutable CntrType ocntr;      
            mutable ValidityOwner usage; 


            typedef void (Owned::*DeleteFn)();
            const DeleteFn cleanerUpper;
        
        private: 
            void doCleanUp() { CntrCleaner<CntrType>::execute(ocntr); }

        private: // no copy allowed
            #ifndef MANGO_ALL_TEMPLATE_INSTANTIATE
            // When the whole template is instantiated, owner 
            // assignment is only possible with Share=oshiptype.
            inline Owned(const Owned&);
            template <typename O2Type> inline 
            Owned(const Owned<O2Type, oshiptype>&);
            inline Owned& operator=(const Owned& rhs);
            template <typename O2Type> 
            inline Owned& operator=(const Owned<O2Type, oshiptype>& rhs);
            #endif
    };
    
    template <typename CntrType, OwnershipType oshiptype>
    inline 
    Owned<CntrType, oshiptype>::Owned(CntrType& cntr)
        : cleanerUpper(&Owned::doCleanUp)
    {
        std::swap(ocntr,cntr);
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    template <typename O2Type>
    inline 
    Owned<CntrType, oshiptype>::Owned(Ownership<O2Type, oshiptype> os)
        : cleanerUpper(&Owned::doCleanUp)
    {
        std::swap(ocntr, os.owner.ocntr);
        assert(os.owner()->empty());
    }

    template <typename CntrType, OwnershipType oshiptype>
    inline 
    Owned<CntrType, oshiptype>::~Owned()
    {
        usage.setValid(false);
        usage.reset(false);
        (this->*cleanerUpper)();
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::swap(Owned& that)
    {
        std::swap(ocntr, that.ocntr);
        /* Do NOT do usage.swap(that.usage) since pointer held by 
           BLink objects is to ocntr, not the inside of ocntr. */
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::swap(CntrType& that) 
    {
        std::swap(that, ocntr);
    }
                    
    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::clear()
    {
        (this->*cleanerUpper)();
        CntrType empty;
        std::swap(empty, ocntr);
        assert(ocntr.empty());
    }
        
    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::unlink()
    const
    {
        usage.setValid(false);
        usage.reset(false);
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::reset()
    {
        clear();
        unlink();
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline Ownership<CntrType, oshiptype> 
    Owned<CntrType, oshiptype>::transfer()
    {
        return Ownership<CntrType, oshiptype>(*this);

    }

    template <typename CntrType, OwnershipType oshiptype>
    inline void 
    Owned<CntrType, oshiptype>::takeOwnership(CntrType& p)
    {
        reset();
        std::swap(p, ocntr);
        assert(p.empty());
    }
        
    template <typename CntrType, OwnershipType oshiptype>
    template <typename O2Type> 
    inline void 
    Owned<CntrType, oshiptype>::takeOwnership(Ownership<O2Type, oshiptype> os)
    {
        clear();
        std::swap(ocntr, os.owner.ocntr);
        assert(os.owner()->empty());
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline void
    Owned<CntrType, oshiptype>::cloneObjNew(CntrType& dest) 
    const 
    {
        assert(dest.empty());
        dest = ocntr;
        CntrCloner<CntrType>::execute(dest);
    }
    
    template <typename CntrType, OwnershipType oshiptype>
    inline CntrType* 
    Owned<CntrType, oshiptype>::shareUsage(ValidityChecker& val) 
    const 
    {
        if (! usage.isValid()) usage.setValid(true);
        val = usage; 
        assert(val.isShared());
        assert(val.isValid());
        return &ocntr;
    }
    


    template <typename CntrType>
    class Owned<CntrType&, OStrict>;
    
} // namespace


#endif // MANGO_OWNED_CONTAINER_H

---