RRefUsage.hh

Go to the documentation of this file.

#ifndef NO_PTR_RREF_USAGE_H
#define NO_PTR_RREF_USAGE_H

#include <assert.h>
#include "nullness.hh"       // use
#include "RefCountedBool.hh" // contain
#include "NoPtrFwd.hh"

namespace NoPtr
{
    
namespace NoPtrImpl
{
    /* This is the base class for RRef usage of DynObj and RRefable's. 
       It exposes rather intimate details of verification strategy 
       of RRef so make sure derived classes use adequate protection. 
       */
    class RRefUsage
    {
        public:
            // Just need to make sure pointer is null
            RRefUsage(): _state(NullPtr) {}
            // nothing special to do since subclasses will decide
           ~RRefUsage() {} // proper destruction by method calls
            // nothing special to do except shallow copy
            RRefUsage(const RRefUsage& rhs): _state(rhs._state) {}
            // just want explicit the fact that shallow copy is wanted
            void operator=(const RRefUsage& rhs) { _state = rhs._state; }
            
            // This assumes we've just been default constructed
            // and \a rhs has a valid state
            void shareFrom(const RRefUsage& rhs)
            {
                assert(_state == NullPtr);
                _state = rhs._state;
                assert(_state && _state->valid);
                _state->count ++;
            }
            // swap with another RRefUsage
            void swap(RRefUsage& rhs)
            {
                RefCountedBool<>* tmp = _state;
                _state = rhs._state;
                rhs._state = tmp;
            }
            
            // useful for testing; create a state with expected values 
            // (or null state) and give it to this method, it will 
            // assert that internal state is same as given 
            void doAssertState(RefCountedBool<>* state) const 
            {
                if (state == NullPtr) assert(_state == NullPtr);
                else assert(*_state == *state);
            }
            
        protected:
            RefCountedBool<>* _state;
    };
    
    /* This is the RRefUsage, as seen by an owner of it, i.e. 
       a DynObj or an RRefable. The owner is the one who can 
       create the RRefUsage state and invalidate it when it is 
       destroyed. Though the malicious use of the public interface 
       could be very damaging, this object is not accessible 
       from outside DynObj and RRef so no special protection is
       needed, unlike RRefUsageForUser. 
       */
    class RRefUsageForOwner: public RRefUsage
    {
        public:
            void swap(RRefUsageForOwner& rhs) {RRefUsage::swap(rhs);}
            // create if doesn't already exist
            void create()
            {
                if (_state == NullPtr) 
                    _state = new RefCountedBool<>(true);
            }
            // if state exists, dec ref count and delete if last one
            void destroy() 
            {
               if (_state)
               {
                   if (-- _state->count) _state->valid = false;
                   else delete _state;
               }
            }
            // Does nothing if no state or we are only user (count=1).
            // Otherwise, do invalidate and dec ref count and leave it
            // to other(s) to delete later
            void reset()
            {
               if (_state && _state->count > 1) 
               {   
                   _state->count --;
                   _state->valid = false;
                   _state = NullPtr;
               }
               // else no _state or = 1 so nothing to do
            }
            
            // could be done with swap but more efficient
            void moveTo(RRefUsageForOwner& rhs)
            {
                assert(rhs._state == NullPtr);
                rhs._state = _state;
                _state = NullPtr;
            }
    };
    
    /* This is an RRefUsage as seen by a user, i.e. by RRef. 
       The state of this object could be obtained and manipulated
       with the right call to DynObj or RRefable so we make 
       it creatable only by RRef, from which it can never be
       obtained. Of course, an adequate specialization of RRef
       could get around that but it at least protects against 
       inadvertent or hacky use (but not against malicious use, 
       which is nigh impossible in C++). 
       */
    class RRefUsageForUser: public RRefUsage
    {
        private:
            // only RRef can create us
            template <typename> friend class ::NoPtr::RRef;
            RRefUsageForUser() {}
        
        public:
            void swap(RRefUsageForUser& rhs) {RRefUsage::swap(rhs);}

            // false if no state or state invalid, true otherwise
            bool isValid() const {return _state && _state->valid;}
            // if state exists, just dec ref count and delete if 
            // last one; don't change validity; do nothing if no state
            void destroy() 
            {
               if (_state && !(-- _state->count)) delete _state;
            }
            // if no state, does nothing; otherwise, dec ref count
            // and if last one, delete it; state is null upon
            // return in \em all cases
            void reset()
            {
               if (_state) 
               {   
                   if ( (-- _state->count) == 0)
                   {
                       // obj *must* have been destroyed
                       assert(! _state->valid);
                       delete _state;
                   }
                   _state = NullPtr;
               }
               // else no _state or = 1 so nothing to do
            }
            
    };
    

} // NoPtrImpl namespace

} // NoPtr namespace

#endif // NO_PTR_RREF_USAGE_H

---