SegmentNode.hh

Go to the documentation of this file.

#ifndef NO_PTR_CHAIN_NODE_1_H
#define NO_PTR_CHAIN_NODE_1_H

#include <algorithm> // use std::swap
#include <assert.h>
#include "NoPtrFwd.hh"
#include "nullness.hh"

namespace NoPtr
{
    namespace NoPtrImpl
    {

    /* Represent a chain node of a one-segment chain (which isn't 
       really a chain, granted). Copying a chain node rather creates 
       a new node and connects it to the original. Connection is 
       only allowed if other node not already connected. E.g.
       \code
            SegmentNode node1;
            SegmentNode node2(node1); // ok
            SegmentNode node3;
            node3.connect(node1); // error: assert fails
            node3.connect(node2); // error: assert fails
        \endcode
        The following would also fail, because of the call to func2:
        \code
        void func1(SegmentNode cn) {func2(cn);}
        void func2(SegmentNode) {} // assertion fails here
        func1( SegmentNode() );
        \endcode
       */
    class SegmentNode
    {
        public:
            // create unconnected
            SegmentNode(): _other(NullPtr) {}
            // connect us to \a rhs
            SegmentNode(SegmentNode& rhs) {connectBare(rhs);}
            // disconnect ourselves
           ~SegmentNode() {removeSelf();}
            void swap(SegmentNode& rhs) { std::swap(_other, rhs._other); }
            // Connect us to another node. This only succeeds if 
            // \a rhs is not connected to anything
            void connect(SegmentNode& rhs) 
            {
                if (this != &rhs)
                {
                    removeSelf();
                    connectBare(rhs);
                }
            }
            // disconnect us from the node we were connected to (if any)
            void disconnect()
            {
                removeSelf();
                _other = NullPtr;
            }
            // are we connected to another node? 
            bool isConnected() const {return _other != NullPtr;}

        private:
            // set the mutual links
            void connectBare(SegmentNode& rhs)
            {
                assert(! rhs.isConnected() );
                rhs._other = this;
                _other = &rhs;
            }
            // Remove self from _other; leave it up to caller to reset
            // _other to something else if necessary;
            void removeSelf()
            {
                if (_other != NullPtr) 
                {
                    assert(_other->_other == this);
                    _other->_other = NullPtr;
                }
            }

        private:
            SegmentNode(const SegmentNode&); // forbidden
            SegmentNode& operator=(const SegmentNode&); // forbidden
                
        private:
            SegmentNode* _other;
    };
    
    } // implementation namespace
    
} // namespace

#endif // NO_PTR_CHAIN_NODE_1_H    

---