Handle pointers back to the list link.

library/include/BitArray.h

@@ -241,6 +241,41 @@ namespace DFHack
         class iterator;
         class const_iterator;
 
+        class proxy
+        {
+            L *cur;
+            friend struct DfLinkedList<L, I>;
+            friend class iterator;
+            proxy(L *cur) : cur(cur)
+            {
+                CHECK_NULL_POINTER(cur);
+            }
+        public:
+            operator I *const &() const
+            {
+                return cur->item;
+            }
+            I *operator->() const
+            {
+                return cur->item;
+            }
+            proxy & operator=(I *const & item)
+            {
+                if (item)
+                {
+                    CHECK_INVALID_ARGUMENT(item->dfhack_get_list_link() == nullptr);
+                    item->dfhack_set_list_link(cur);
+                }
+                if (cur->item)
+                {
+                    cur->item->dfhack_set_list_link(nullptr);
+                }
+                cur->item = item;
+
+                return *this;
+            }
+        };
+
         class iterator
         {
             L *root;
@@ -252,7 +287,7 @@ namespace DFHack
             using difference_type = void;
             using value_type = I *;
             using pointer = I **;
-            using reference = I * &;
+            using reference = proxy;
             using iterator_category = std::bidirectional_iterator_tag;
 
             iterator() : root(nullptr), cur(nullptr) {}
@@ -304,12 +339,12 @@ namespace DFHack
                 return *this;
             }
 
-            I * & operator*()
+            proxy operator*()
             {
                 CHECK_NULL_POINTER(root);
                 CHECK_NULL_POINTER(cur);
 
-                return cur->item;
+                return proxy(cur);
             }
 
             I *const & operator*() const
@@ -388,10 +423,10 @@ namespace DFHack
             }
         };
 
-        typedef I *value_type;
+        using value_type = I *;
-        typedef I * & reference_type;
+        using reference_type = proxy;
-        typedef void difference_type;
+        using difference_type = void;
-        typedef size_t size_type;
+        using size_type = size_t;
 
         bool empty() const
         {
@@ -400,7 +435,7 @@ namespace DFHack
         size_t size() const
         {
             size_t n = 0;
-            for (I *i : *this)
+            for (value_type const & i : *this)
                 n++;
             return n;
         }
@@ -411,7 +446,7 @@ namespace DFHack
         }
         const_iterator begin() const
         {
-            return const_iterator(static_cast<L *>(this), static_cast<L *>(this)->next);
+            return const_iterator(const_cast<DfLinkedList<L, I> *>(this)->begin());
         }
         const_iterator cbegin() const
         {
@@ -423,7 +458,7 @@ namespace DFHack
         }
         const_iterator end() const
         {
-            return const_iterator(static_cast<L *>(this), nullptr);
+            return const_iterator(const_cast<DfLinkedList<L, I> *>(this)->end());
         }
         const_iterator cend() const
         {
@@ -438,25 +473,24 @@ namespace DFHack
 
             auto link = pos.iter.cur;
             auto next = link->next;
-            if (link->next && link->prev)
+
+            if (link->prev)
             {
-                link->next->prev = link->prev;
                 link->prev->next = link->next;
             }
-            else if (link->next)
+            else
-            {
-                link->next->prev = nullptr;
-            }
-            else if (link->prev)
             {
-                link->prev->next = nullptr;
+                root->next = link->next;
             }
 
-            if (root->next == link)
+            if (link->next)
             {
-                root->next = next;
+                link->next->prev = link->prev;
             }
 
+            proxy p(link);
+            p = nullptr;
+
             delete link;
 
             return iterator(root, next);
@@ -492,7 +526,9 @@ namespace DFHack
             {
                 root->next = newlink;
             }
-            newlink->item = item;
+            newlink->item = nullptr;
+            proxy p(newlink);
+            p = item;
             return iterator(root, newlink);
         }
         iterator insert_after(const_iterator pos, I *const & item)
@@ -511,7 +547,9 @@ namespace DFHack
             {
                 next->prev = newlink;
             }
-            newlink->item = item;
+            newlink->item = nullptr;
+            proxy p(newlink);
+            p= item;
             return iterator(root, newlink);
         }
         void push_front(I *const & item)
@@ -524,7 +562,9 @@ namespace DFHack
                 root->next->prev = link;
                 link->next = root->next;
             }
-            link->item = item;
+            link->item = nullptr;
+            proxy p(link);
+            p = item;
             root->next = link;
         }
     };