src/lib/DataStructures/Fifo.vala

@@ -80,6 +80,7 @@ namespace Invercargill.DataStructures {
                 throw new SequenceError.NO_ELEMENTS("No elements in unblocked queue to pop");
             }
             var result = item->item;
+            item->item = null;
             delete item;
             return result;
         }
@@ -125,6 +126,7 @@ namespace Invercargill.DataStructures {
             first_item = item->next_item;            
             mutex.unlock();
             var result = item->item;
+            item->item = null;
             delete item;
             return result;
         }
@@ -144,6 +146,7 @@ namespace Invercargill.DataStructures {
             while(n != null) {
                 var c = n;
                 n = n->next_item;
+                c->item = null;
                 delete c;
             }
         }

src/lib/DataStructures/HashSet.vala

@@ -7,6 +7,11 @@ namespace Invercargill.DataStructures {
         private class HashSetItem<T> {
             public uint hash;
             public T item;
+
+            public HashSetItem(owned T item, uint hash) {
+                this.item = (owned)item;
+                this.hash = hash;
+            }
         }
 
         private HashSetItem<T>* tombstone;
@@ -28,7 +33,7 @@ namespace Invercargill.DataStructures {
         }
 
         private void setup(HashDelegate<T>? value_hash_func = null, EqualityDelegate<T>? value_equal_func = null) {
-            tombstone = new HashSetItem<T>();
+            tombstone = new HashSetItem<T>(null, 0);
             hash_func = value_hash_func ?? Operators.hash<T>();
             equal_func = value_equal_func ?? Operators.equality<T>();
             safe_read = get_safe_read_function_for<T>();
@@ -120,9 +125,7 @@ namespace Invercargill.DataStructures {
                 bucket = buckets[bucket_index];
             }
             
-            HashSetItem<T>* new_bucket = new HashSetItem<T>();
-            new_bucket->hash = bucket_hash;
-            new_bucket->item = (owned)item;
+            HashSetItem<T>* new_bucket = new HashSetItem<T>((owned) item, bucket_hash);
             buckets[bucket_index] = new_bucket;
             n_items++;
             return true;
@@ -174,6 +177,7 @@ namespace Invercargill.DataStructures {
                 if(buckets[bucket_index] != tombstone) {
                     var ours = buckets[bucket_index]->item;
                     if(equal_func(ours, item)) {
+                        buckets[bucket_index]->item = null;
                         delete buckets[bucket_index];
                         buckets[bucket_index] = tombstone;
                         n_items--;
@@ -195,8 +199,10 @@ namespace Invercargill.DataStructures {
 
         private void delete_items() {
             for(uint i = 0; i < buckets.length; i++) {
-                if(buckets[i] != null && buckets[i] != tombstone)
-                delete buckets[i];
+                if(buckets[i] != null && buckets[i] != tombstone) {
+                    buckets[i]->item = null;
+                    delete buckets[i];
+                }
             }
         }
 

src/lib/DataStructures/Lifo.vala

@@ -27,9 +27,7 @@ namespace Invercargill.DataStructures {
 
         public void push(owned T item) {
             mutex.lock();
-            LifoItem<T>* lifo_item = new LifoItem<T>() {
-                item = item,
-            };
+            LifoItem<T>* lifo_item = new LifoItem<T>((owned) item);
 
             if(top_item == null) {
                 top_item = lifo_item;
@@ -47,9 +45,7 @@ namespace Invercargill.DataStructures {
              mutex.lock();
 
              foreach (var item in items) {
-                LifoItem<T>* lifo_item = new LifoItem<T>() {
-                    item = item,
-                };
+                LifoItem<T>* lifo_item = new LifoItem<T>(item);
     
                 if(top_item == null) {
                     top_item = lifo_item;
@@ -79,6 +75,7 @@ namespace Invercargill.DataStructures {
                 throw new SequenceError.NO_ELEMENTS("No elements in unblocked stack to pop");
             }
             var result = item->item;
+            item->item = null;
             delete item;
             return result;
         }
@@ -113,6 +110,7 @@ namespace Invercargill.DataStructures {
             top_item = item->next_item;            
             mutex.unlock();
             var result = item->item;
+            item->item = null;
             delete item;
             return result;
         }
@@ -132,6 +130,7 @@ namespace Invercargill.DataStructures {
             while(n != null) {
                 var c = n;
                 n = n->next_item;
+                c->item = null;
                 delete c;
             }
         }
@@ -140,6 +139,10 @@ namespace Invercargill.DataStructures {
         private class LifoItem<T> {
             public T item;
             public LifoItem<T>* next_item;
+
+            public LifoItem(owned T item) {
+                this.item = (owned)item;
+            }
         }
 
     }

src/lib/DataStructures/PriorityQueue.vala

@@ -73,6 +73,7 @@ namespace Invercargill.DataStructures {
                 bubble_down(0);
             }
             
+            item->item = null;
             delete item;
             mutex.unlock();
             return result;
@@ -163,6 +164,7 @@ namespace Invercargill.DataStructures {
                 bubble_down(0);
             }
             
+            item->item = null;
             delete item;
             mutex.unlock();
             return result;
@@ -179,7 +181,9 @@ namespace Invercargill.DataStructures {
 
         ~PriorityQueue() {
             for (uint i = 0; i < items.length; i++) {
-                delete items.get(i);
+                var queue_item = items.get(i);
+                queue_item->item = null;
+                delete queue_item;
             }
         }
 

src/lib/DataStructures/Series.vala

@@ -129,6 +129,7 @@ namespace Invercargill.DataStructures {
                     var old_root = root;
                     root = root->next;
                     item = old_root->value;
+                    old_root->value = null;
                     delete old_root;
                     n_items--;
                     if(root == null) {
@@ -154,18 +155,22 @@ namespace Invercargill.DataStructures {
                 SeriesItem<T>* previous = null;
                 SeriesItem<T>* node = root;
                 while(node != null) {
-                    if(predicate(node->value)) {
-                        if(previous == null) {
-                            root = node->next;
-                        }
-                        else {
-                            previous->next = node->next;
-                        }
-                        delete node;
-                        n_items--;
+                        if(predicate(node->value)) {
+                            SeriesItem<T>* next = node->next;
+                            if(previous == null) {
+                                root = next;
+                            }
+                            else {
+                                previous->next = next;
+                            }
+                            node->value = null;
+                            delete node;
+                            n_items--;
                         if(first_only) {
                             break;
                         }
+                        node = next;
+                        continue;
                     }
                     previous = node;
                     node = node->next;

src/tests/Integration/Fifo.vala

@@ -209,4 +209,48 @@ void fifo_tests() {
         assert_cmpstr("second", CompareOperator.EQ, fifo.pop());
     });
 
+    Test.add_func("/invercargill/fifo/pop_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var fifo = new Fifo<OwnershipProbe>();
+        fifo.push(probe);
+        fifo.push(probe);
+        assert(probe.ref_count == 3);
+        fifo.unblock();
+        while(true) {
+            try {
+                fifo.pop();
+            }
+            catch(SequenceError e) {
+                break;
+            }
+        }
+        assert(probe.ref_count == 1);
+    });
+
+    Test.add_func("/invercargill/fifo/destructor_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var fifo = new Fifo<OwnershipProbe>();
+        fifo.push(probe);
+        assert(probe.ref_count == 2);
+        fifo = null;
+        assert(probe.ref_count == 1);
+    });
+
+    Test.add_func("/invercargill/fifo/stores_owned_copies_of_temporaries", () => {
+        var fifo = new Fifo<string>();
+        string source = "stable";
+        for(int i = 0; i < 50; i++) {
+            fifo.push("temporary-%d".printf(i));
+            fifo.push(source.dup());
+        }
+        fifo.unblock();
+        uint found = 0;
+        foreach(var item in fifo) {
+            if(item.has_prefix("temporary-") || item == "stable") {
+                found++;
+            }
+        }
+        assert(found == 100);
+    });
+
 }

src/tests/Integration/Lifo.vala

@@ -209,4 +209,31 @@ void lifo_tests() {
         assert_cmpstr("first", CompareOperator.EQ, lifo.pop());
     });
 
+    Test.add_func("/invercargill/lifo/pop_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var lifo = new Lifo<OwnershipProbe>();
+        lifo.push(probe);
+        lifo.push(probe);
+        assert(probe.ref_count == 3);
+        lifo.unblock();
+        while(true) {
+            try {
+                lifo.pop();
+            }
+            catch(SequenceError e) {
+                break;
+            }
+        }
+        assert(probe.ref_count == 1);
+    });
+
+    Test.add_func("/invercargill/lifo/destructor_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var lifo = new Lifo<OwnershipProbe>();
+        lifo.push(probe);
+        assert(probe.ref_count == 2);
+        lifo = null;
+        assert(probe.ref_count == 1);
+    });
+
 }

src/tests/Integration/PriorityQueue.vala

@@ -272,4 +272,31 @@ void priority_queue_tests() {
         assert_cmpstr("zebra", CompareOperator.EQ, pq.pop());
     });
 
+    Test.add_func("/invercargill/priority_queue/pop_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var pq = new PriorityQueue<OwnershipProbe>((a, b) => 0);
+        pq.push(probe);
+        pq.push(probe);
+        assert(probe.ref_count == 3);
+        pq.unblock();
+        while(true) {
+            try {
+                pq.pop();
+            }
+            catch(SequenceError e) {
+                break;
+            }
+        }
+        assert(probe.ref_count == 1);
+    });
+
+    Test.add_func("/invercargill/priority_queue/destructor_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var pq = new PriorityQueue<OwnershipProbe>((a, b) => 0);
+        pq.push(probe);
+        assert(probe.ref_count == 2);
+        pq = null;
+        assert(probe.ref_count == 1);
+    });
+
 }

src/tests/Integration/Series.vala

@@ -32,4 +32,65 @@ void series_tests() {
             assert(array[i] == items[i]);
         }
     });
+
+    Test.add_func("/invercargill/structure/series/stores_owned_copies_of_temporaries", () => {
+        var series = new Series<string>();
+        string source = "stable";
+        for(int i = 0; i < 100; i++) {
+            series.add("temporary-%d".printf(i));
+            series.add(source.dup());
+        }
+        series.clear();
+        for(int i = 0; i < 100; i++) {
+            series.add("temporary-%d".printf(i));
+            series.add(source.dup());
+        }
+        uint found = 0;
+        foreach(var item in series) {
+            if(item.has_prefix("temporary-") || item == "stable") {
+                found++;
+            }
+        }
+        assert(found == series.count());
+        assert(found == 200);
+    });
+
+    Test.add_func("/invercargill/structure/series/pop_start_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var series = new Series<OwnershipProbe>();
+        series.add(probe);
+        assert(probe.ref_count == 2);
+        try {
+            series.pop_start();
+        }
+        catch(SequenceError e) {
+            assert_not_reached();
+        }
+        assert(probe.ref_count == 1);
+    });
+
+    Test.add_func("/invercargill/structure/series/remove_where_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var kept = new OwnershipProbe();
+        var series = new Series<OwnershipProbe>();
+        series.add(probe);
+        series.add(kept);
+        assert(probe.ref_count == 2);
+        series.remove_first_where(p => p == probe);
+        assert(probe.ref_count == 1);
+        assert(kept.ref_count == 2);
+        series.remove_all_where(p => true);
+        assert(kept.ref_count == 1);
+        assert(series.count() == 0);
+    });
+
+    Test.add_func("/invercargill/structure/series/clear_releases_ownership", () => {
+        var probe = new OwnershipProbe();
+        var series = new Series<OwnershipProbe>();
+        series.add(probe);
+        series.add(probe);
+        assert(probe.ref_count == 3);
+        series.clear();
+        assert(probe.ref_count == 1);
+    });
 }

src/tests/TestRunner.vala

@@ -1,4 +1,7 @@
 
+public class OwnershipProbe : Object {
+}
+
 public static int main(string[] args) {
 
     Test.init(ref args);