Changes in src/AST/Node.hpp [87701b6:54e41b3]

File:

• src/AST/Node.hpp (modified) (7 diffs)

src/AST/Node.hpp

@@ -44 +44 @@
         };
 
-private:
-        /// Make a copy of this node; should be overridden in subclass with more precise return type
-        virtual Node * clone() const = 0;
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
-
-        mutable size_t strong_count = 0;
-        mutable size_t weak_count = 0;
-
-        void increment(ref_type ref) const {
+        inline void increment(ref_type ref) const {
                 switch (ref) {
                         case ref_type::strong: strong_count++; break;
@@ -62 +51 @@
         }
 
-        void decrement(ast::Node::ref_type ref) const {
+        inline void decrement(ref_type ref) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -72 +61 @@
                 }
         }
+private:
+        /// Make a copy of this node; should be overridden in subclass with more precise return type
+        virtual const Node * clone() const = 0;
 
-        template< typename node_t, enum Node::ref_type ref_t >
-        friend class ptr_base;
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend auto mutate(const node_t * node);
+
+        mutable size_t strong_count = 0;
+        mutable size_t weak_count = 0;
 };
 
@@ -80 +76 @@
 // problems and be able to use auto return
 template<typename node_t>
-node_t * mutate( const node_t * node ) {
-        if (node->strong_count <= 1) {
+auto mutate( const node_t * node ) {
+        assertf(
+                node->strong_count >= 1,
+                "Error: attempting to mutate a node that appears to have been linked"
+        );
+        if (node->strong_count == 1) {
                 return const_cast<node_t *>(node);
         }
@@ -100 +100 @@
 public:
         ptr_base() : node(nullptr) {}
-        ptr_base( const node_t * n ) : node(n) { if( node ) _inc(node); }
-        ~ptr_base() { if( node ) _dec(node); }
+        ptr_base( const node_t * n ) : node(n) { if( node ) increment(node, ref_t); }
+        ~ptr_base() { if( node ) decrement(node, ref_t); }
 
         template< enum Node::ref_type o_ref_t >
         ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
-                if( node ) _inc(node);
+                if( node ) increment(node, ref_t);
         }
 
         template< enum Node::ref_type o_ref_t >
         ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
-                if( node ) _inc(node);
+                if( node ) increment(node, ref_t);
         }
 
@@ -147 +147 @@
                 assign( n );
                 // get mutable version of `n`
-                auto r = mutate( node );
+                auto r = mutate( node ); 
                 // re-assign mutable version in case `mutate()` produced a new pointer
                 assign( r );
@@ -157 +157 @@
 private:
         void assign( const node_t * other ) {
-                if( other ) _inc(other);
-                if( node  ) _dec(node );
+                if( other ) increment(other, ref_t);
+                if( node  ) decrement(node , ref_t);
                 node = other;
         }
-
-        void _inc( const node_t * other );
-        void _dec( const node_t * other );
 
 protected: