---

BLink.hh

Go to the documentation of this file.

#ifndef MANGO_BLINK_H
#define MANGO_BLINK_H

#include "nullness.hh"      // use
#include "ValidityChecker.hh" // contain
#include "CheckedPtr.hh"    // use
#include "BLinkable.hh"     // use
#include "OwnedFWD.hh"      // use
#include "BLinkFWD.hh"      // use

namespace MangoPtr
{
    // Overload of isNull(T*) for BLink types
    template <typename T>
    inline bool 
    isNull(const BLink<T>& p) {return p.isNull();}
    
    // Overload of isNotNull(T*) for BLink types
    template <typename T>
    inline bool 
    isNotNull(const BLink<T>& p) {return p.isNotNull();}


    template <typename OType>
    class BLink
    {
        private:
            typedef OType* PType;

        public:
            template <typename OType2> friend class BLink; 
            typedef OType ObjectType;

        public:


            BLink() throw(): optr(NullPtr) {}
            
            inline BLink(const BLink&);
            template <typename OType2> inline
            BLink(const BLink<OType2>&);
            
            inline BLink(OType&);
            template <typename OType2, OwnershipType oshiptype> explicit inline
            BLink(const Owned<OType2, oshiptype>&);

        public:

            template <typename OType2, OwnershipType oshiptype>
            inline void tieTo(const Owned<OType2, oshiptype>&);
            inline void tieTo(OType&);
            inline BLink& operator=(const BLink&);
            template <typename OType2>
            inline BLink& operator=(const BLink<OType2>&);
            inline void swap(BLink&) throw();
            inline void reset() {validator.reset(); nullify(optr);}



            inline bool isNotNull() const throw();
            inline bool isNull() const throw() {return ! isNotNull();}
            inline PType cloneObjNew() const;

        public: // pointer access operators


            #include "opConstWarningOff.pp"
            inline operator const BLink<const OType>&() const;
            #include "opConstWarningOn.pp"
            template <typename OType2>
            inline bool operator<(const BLink<OType2>&) const throw();
            template <typename OType2>
            inline bool operator==(const BLink<OType2>&) const throw();
            template <typename OType2>
            inline bool operator!=(const BLink<OType2>&) const throw();
            CheckedPtr<OType> operator()() const {return isNotNull() ? optr : NullPtr;}
            OType* ptr() const {return isNotNull() ? optr : NullPtr;}

        private:
            PType optr;                
            ValidityChecker validator; 
    };

    template <typename OType> inline
    BLink<OType>::BLink(const BLink& rhs)
        : optr(rhs.optr), validator(rhs.validator) 
    {
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }
    
    template <typename OType>
    template <typename OType2> inline 
    BLink<OType>::BLink(const BLink<OType2>& rhs)
        : optr(rhs.optr), validator(rhs.validator) 
    {
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }

    template <typename OType>
    template <typename OType2, OwnershipType oshiptype> inline
    BLink<OType>::BLink(const Owned<OType2, oshiptype>& owner)
        : optr(NullPtr) 
    { 
        tieTo(owner); 
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }
            
    template <typename OType> inline 
    BLink<OType>::BLink(OType& oobj)
        : optr(&oobj), validator(oobj.getValidityOwner()) 
    {
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }
                  

    template <typename OType>
    inline bool 
    BLink<OType>::isNotNull() 
    const throw() 
    {
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
        return validator.isValid();
    }
                
    template <typename OType>
    inline BLink<OType>& 
    BLink<OType>::operator=(const BLink& rhs) 
    {
        validator = rhs.validator; // first since could throw
        assert(validator.isShared());
        optr = rhs.optr;
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
        return *this;
    }

    template <typename OType>
    template <typename OType2>
    inline BLink<OType>& 
    BLink<OType>::operator=(const BLink<OType2>& rhs) 
    {
        validator = rhs.validator; // first since could throw
        assert(validator.isShared());
        optr = rhs.optr;
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
        return *this;
    }

    template <typename OType>
    template <typename OType2, OwnershipType oshiptype>
    inline void 
    BLink<OType>::tieTo(const Owned<OType2, oshiptype>& owner) 
    {
        optr = owner.shareUsage(validator);
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }
    
    template <typename OType>
    inline void 
    BLink<OType>::tieTo(OType& blinkable)
    {
        optr = &blinkable;
        validator = blinkable.getValidityOwner(); 
        assert(validator.isShared());
        // assert that if optr null, validator is invalid
        assert(MangoPtr::isNotNull(optr) || ! validator.isValid());
    }
    
    template <typename OType>
    inline void 
    BLink<OType>::swap(BLink& rhs) 
    throw() 
    {
        std::swap(optr, rhs.optr);
        validator.swap(rhs.validator);
    }
    
    template <typename OType>
    inline 
    BLink<OType>::operator const BLink<const OType>&() 
    const 
    {
        return * static_cast<const BLink<const OType>*>(
                     static_cast<const void*>(this)
                 );
    }

    template <typename OType>
    template <typename OType2>
    inline bool 
    BLink<OType>::operator<(const BLink<OType2>& rhs) 
    const throw() 
    { 
        return optr < rhs.optr; 
    }

    template <typename OType>
    template <typename OType2>
    inline bool 
    BLink<OType>::operator==(const BLink<OType2>& rhs) 
    const throw()
    {
        return rhs == optr;
    }

    template <typename OType>
    template <typename OType2>
    inline bool 
    BLink<OType>::operator!=(const BLink<OType2>& rhs) 
    const throw()
    {
        return ! (rhs == optr);
    }
            
    template <typename OType> inline
    OType*
    BLink<OType>::cloneObjNew() 
    const 
    { 
        return isNotNull() ? new OType(*optr) : NullPtr; 
    }

} // namespace MangoPtr

#endif // MANGO_BLINK_H

---