RRef.hh

Go to the documentation of this file.

#ifndef NO_PTR_RREF_H
#define NO_PTR_RREF_H

#include "nullness.hh"  // use
#include "RRefUsage.hh" // use
#include "NoPtrFwd.hh"  // use

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

    template <typename TT>
    inline bool 
    isNotNull(const RRef<TT>& p) {return p.isNotNull();}
    
    template <typename ObjType>
    class RRef
    {
        public:
            typedef ObjType ObjectType;

        public:
                
            RRef() throw(): _obj(NullPtr) {}
        
            RRef(const RRef& rhs): _obj(rhs.getPtr()) 
            { 
                if (_obj) _rrefUsage.shareFrom(rhs._rrefUsage);
            }

            template <typename ObjType2> 
            RRef(const RRef<ObjType2>& rhs): _obj(rhs.getPtr()) 
            { 
                if (_obj) _rrefUsage.shareFrom(rhs._rrefUsage);
            }
            
            template <typename ObjType2, class Context> 
            RRef(const DynObj<ObjType2,Context>& rhs)
                : _obj(rhs.getPtr()) 
            { 
                if (_obj) 
                {
                    rhs.getRRefUsage(_rrefUsage);
                    assert(_rrefUsage.isValid());
                }
            }
            
            RRef(ObjType& rrefable): _obj(&rrefable)
            { 
                rrefable.getRRefUsage(_rrefUsage);
                assert(_rrefUsage.isValid());
            }
            
            
            // Just need to destroy our share of _rrefUsage
           ~RRef() { _rrefUsage.destroy(); }

        public:
                
            void reset() 
            { 
                _obj = NullPtr; 
                _rrefUsage.reset();
            }
        
            template <typename ObjType2>
            void reset(const RRef<ObjType2>& rhs) 
            { 
                ObjType2* const obj = rhs.getPtr();
                if (obj == _obj) return;
                
                _rrefUsage.reset();
                _obj = obj; 
                if (_obj) _rrefUsage.shareFrom(rhs._rrefUsage);
            }
            
            template <typename ObjType2, class Context>
            void reset(const DynObj<ObjType2,Context>& rhs)
            { 
                ObjType2* const obj = rhs.getPtr();
                if (obj == _obj) return;
                
                _rrefUsage.reset();
                _obj = obj; 
                if (_obj) 
                {
                    rhs.getRRefUsage(_rrefUsage);
                    assert(_rrefUsage.isValid());
                }
            }
            void reset(ObjType& rrefable) 
            { 
                if (_obj == &rrefable) return;
                
                _rrefUsage.reset();
                _obj = &rrefable; 
                rrefable.getRRefUsage(_rrefUsage);
                assert(_rrefUsage.isValid());
            }
            
            
            
            void swap(RRef& rhs) throw() 
            {
                std::swap(_obj, rhs._obj);
                _rrefUsage.swap(rhs._rrefUsage);
            }
            
            bool isNotNull() const throw() {return getPtr() != NullPtr;}
            bool isNull()    const throw() {return getPtr() == NullPtr;}

            ObjType* getPtr() const throw() 
            { 
                return _rrefUsage.isValid() ? _obj : NullPtr; 
            }
            
        public: // pointer access operators

                
            ObjType& operator()() const
            {
                return *(operator->());
            }
            
            ObjType& operator*() const
            {
                return *(operator->());
            }
            
            RRef& operator=(const RRef& rhs) 
            { 
                reset(rhs); 
                return *this;
            }
            template <typename ObjType2>
            RRef& operator=(const RRef<ObjType2>& rhs)
            {
                reset(rhs);
                return *this;
            }
            template <typename ObjType2, class Context>
            RRef& operator=(const DynObj<ObjType2,Context>& rhs)
            {
                reset(rhs);
                return *this;
            }
            RRef& operator=(ObjType& rrefable) 
            { 
                reset(rrefable);
                return *this;
            }
            
            #include "opConstWarningOff.hpp"
            inline operator const RRef<const ObjType>&() const throw()
            {
                return * static_cast<const RRef<const ObjType>*>(
                     static_cast<const void*>(this)
                );
            }
            #include "opConstWarningOn.hpp"
            template <typename ObjType2>
            inline bool operator<(const RRef<ObjType2>& rhs) const throw()
            {
                ObjType* const lhsp = getPtr();
                ObjType2* const rhsp = rhs.getPtr();
                if (lhsp && rhsp) // both non-null:
                    return (*lhsp) < *(rhsp);
                
                // at least one null, compare pointers
                if (lhsp == NullPtr) return true;
                // else rhs must be null, so result is false:
                assert(rhsp == NullPtr);
                return false;
            }
            template <typename ObjType2>
            bool operator==(const RRef<ObjType2>& rhs) const throw()
            {
                ObjType* const lhsp = getPtr();
                ObjType2* const rhsp = rhs.getPtr();
                if (lhsp && rhsp) return (lhsp == rhsp) || (*lhsp == *rhsp);
                return lhsp == rhsp;
            }
            template <typename ObjType2>
            bool operator!=(const RRef<ObjType2>& rhs) const throw()
            {
                return ! (*this == rhs);
            }
            
        private:
            template <typename> friend class RRef;
            
            ObjType* operator->() const
            {
                assert( _rrefUsage.isValid() );
                return getPtr();
            }
            
        private:
            ObjType* _obj;
            NoPtrImpl::RRefUsageForUser _rrefUsage;
    };

    
} // namespace

#endif // NO_PTR_RREF_H

---