Contexts.hh

Go to the documentation of this file.

#ifndef NO_PTR_CONTEXTS_H
#define NO_PTR_CONTEXTS_H

#include "SegmentNode.hh" // typedef template param
#include "ChainNode.hh" // typedef template param

namespace NoPtr
{
    namespace NoPtrImpl
    {

    /*  The default context for DynObj is the "no context", i.e. 
        a DynObj in a class or function, but not in a container.
        It basically does nothing, has no data, etc and should 
        be completely optimized away by compiler.
        */
    class DefaultDynObjContext
    {
        protected:
            DefaultDynObjContext() {}
           ~DefaultDynObjContext() {}
            // When free, we are always the sole owner
            bool soleOwner() const {return true;}
            void swap(DefaultDynObjContext&) {}
            // don't define checkCopyable();
            // so that a compile error is generated instead of assert
            
        private:
            void operator=(const DefaultDynObjContext&); // not allowed
            DefaultDynObjContext(const DefaultDynObjContext&); // not allowed
    };
         
    /*  This context represents the "inside a value container" context. 
        It allows shallow copy of DynObj by keeping track, via the 
        use of a chain node (template parameter ChainType) that 
        gets linked when the context is copied. This way, the DynObj
        knows if it should delete its pointer when destroyed by 
        calling soleOwner(), which will return true only if the 
        DynObj isn't currently sharing the DAO with any other DynObj.
        Note that it is up to DynObj to enforce that its methods 
        are called only when soleOwner() is true. 
        */
    template <class ChainType>   
    class InValueContainer
    {
        protected:
            InValueContainer() {}
           ~InValueContainer() {}
            InValueContainer(const InValueContainer& rhs)
                : _chainNode(rhs._chainNode) {}
            InValueContainer& operator=(const InValueContainer& rhs)
            {
                _chainNode.connect(rhs._chainNode);
                return *this;
            }
            void swap(InValueContainer& rhs) 
            {
                _chainNode.swap(rhs._chainNode);
            }
            
            // we're the sole owner only if chain not connected to anything else
            bool soleOwner() const {return ! _chainNode.isConnected();}
            // this is a way of getting compilation to fail if context 
            // does not allow shallow copying
            static void checkCopyable() {}
            
        private:
            // This is not state, just technique
            mutable ChainType _chainNode;
    };
    
    typedef size_t RefCount;
    
    /*  Most generic implementation of "inside a value-based
        container"  context, i.e. using reference count. This will be
        the default  non-free context implementation, but if you know
        that  one of the other ones will work you can get speed gains 
        by using InValueContainer<Segment> or
        InValueContainer<ChainNode>.

        Implementation note: the ref count is allocated at construction
        of the context object. This saves on several checks for
        nullness that would have to be done if it were created only
        when used the  first time. Moreover, this context implies that
        an object created  will require copy almost immediately e.g.
        during insertion so  in practice the case of allocating the
        count and not making use  of it is much more seldom than the
        reverse situation. */
    template <>   
    class InValueContainer<RefCount>
    {
        protected:
            InValueContainer(): _sharedOwnerCount(new RefCount(1)) {}
            InValueContainer(const InValueContainer& rhs)
                : _sharedOwnerCount(rhs._sharedOwnerCount) 
            {
                (*_sharedOwnerCount) ++;
            }
            void operator=(const InValueContainer& rhs) 
            {
                clearCount();
                _sharedOwnerCount = rhs._sharedOwnerCount;
                (*_sharedOwnerCount) ++;
            }
            
           ~InValueContainer() 
            {
                clearCount();
            }
            
            void swap(InValueContainer& rhs) 
            {
                std::swap(_sharedOwnerCount, rhs._sharedOwnerCount);
            }
           
            bool soleOwner() const 
            {
                return ((*_sharedOwnerCount) == 1);
            }
            // this is a way of getting compilation to fail if context 
            // does not allow shallow copying
            static void checkCopyable() {}
            
        private:
            void clearCount() 
            {
                if ((--(*_sharedOwnerCount)) <= 0) 
                    delete _sharedOwnerCount;
            }
            
        private:
            RefCount* _sharedOwnerCount;
    };
    
    /* This used to be InValueContainer<RefCount> but was found to 
       have 10% less performance than current implementation. 
       This is because when the _sharedOwnerCount is initialized 
       only when used, there are several checks for nullness that 
       must be included. Creating the count upon construction 
       has the potential overhead that the count is not used, but
       in practice it is still better the old implementation.
        */
    template <>   
    class InValueContainer<void>
    {
        protected:
            InValueContainer(): _sharedOwnerCount(NullPtr) {}
            InValueContainer(const InValueContainer& rhs)
                : _sharedOwnerCount(rhs.getCount()) 
            {
                (*_sharedOwnerCount) ++;
            }
            void operator=(const InValueContainer& rhs) 
            {
                clearCount();
                _sharedOwnerCount = rhs.getCount();
                (*_sharedOwnerCount) ++;
            }
            
           ~InValueContainer() 
            {
                clearCount();
            }
            
            void swap(InValueContainer& rhs) 
            {
                std::swap(_sharedOwnerCount, rhs._sharedOwnerCount);
            }
           
            bool soleOwner() const 
            {
                return ((_sharedOwnerCount == NullPtr) 
                        || (*_sharedOwnerCount) == 1);
            }
            // this is a way of getting compilation to fail if context 
            // does not allow shallow copying
            static void checkCopyable() {}
            
        private:
            RefCount* getCount() const 
            {
                if (!_sharedOwnerCount) 
                    const_cast<RefCount*&>(_sharedOwnerCount) = new RefCount(1);
                    //_sharedOwnerCount = new RefCount(1);
                return _sharedOwnerCount;
            }
            void clearCount() 
            {
                if (_sharedOwnerCount && (--(*_sharedOwnerCount)) <= 0) 
                    delete _sharedOwnerCount;
            }
            
        private:
            RefCount* _sharedOwnerCount;
    };
    
    } // implementation namespace
    
} // namespace

#endif // NO_PTR_CONTEXTS_H    

---