Improvements to sort, Sequence, and BinaryData

src/lib/Concrete/BinaryData.vala

@@ -26,18 +26,45 @@ namespace Invercargill {
             endianness = Endianness.Native;
         }
 
+        public BinaryData.from_bytes(Bytes data) {
+            chunks = Invercargill.single(ate(data.get_data()));
+            endianness = Endianness.Native;
+        }
+
+        public BinaryData.from_byte_array(uint8[] data) {
+            chunks = Invercargill.single(ate(data));
+            endianness = Endianness.Native;
+        }
+
+        public BinaryData.from_base64(string data) {
+            chunks = Invercargill.single(ate(Base64.decode(data)));
+            endianness = Endianness.Native;
+        }
+
         public void append(Enumerable<uint8> data) {
             lock(chunks) {
                 chunks = chunks.with(data);
             }
         }
 
+        public void append_all(Enumerable<Enumerable<uint8>> data) {
+            lock(chunks) {
+                chunks = chunks.concat(data);
+            }
+        }
+
         public void prepend(Enumerable<uint8> data) {
             lock(chunks) {
                 chunks = Invercargill.single(data).concat(chunks);
             }
         }
 
+        public void prepend_all(Enumerable<Enumerable<uint8>> data) {
+            lock(chunks) {
+                chunks = data.concat(chunks);
+            }
+        }
+
         public void append_byte_array(uint8[] data) {
             append(ate(data.copy()));
         }
@@ -88,6 +115,10 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+        public void push_all_int64(Enumerable<int64?> values) {
+            values.iterate(i => push_int64(i));
+        }
+
         public void push_uint64(uint64 value) {
             var chunk = new uint8[sizeof(uint64)];
             uint64 val;
@@ -106,6 +137,11 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+
+        public void push_all_uint64(Enumerable<uint64?> values) {
+            values.iterate(i => push_uint64(i));
+        }
+
         public void push_int32(int32 value) {
             var chunk = new uint8[sizeof(int32)];
             int32 val;
@@ -124,6 +160,10 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+        public void push_all_int32(Enumerable<int32?> values) {
+            values.iterate(i => push_int32(i));
+        }
+
         public void push_uint32(uint32 value) {
             var chunk = new uint8[sizeof(uint32)];
             uint32 val;
@@ -142,6 +182,10 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+        public void push_all_uint32(Enumerable<uint32?> values) {
+            values.iterate(i => push_uint32(i));
+        }
+
         public void push_int16(int16 value) {
             var chunk = new uint8[sizeof(int16)];
             int16 val;
@@ -160,6 +204,10 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+        public void push_all_int16(Enumerable<int16?> values) {
+            values.iterate(i => push_int16(i));
+        }
+
         public void push_uint16(uint16 value) {
             var chunk = new uint8[sizeof(uint16)];
             uint16 val;
@@ -178,17 +226,29 @@ namespace Invercargill {
             append(ate(chunk));
         }
 
+        public void push_all_uint16(Enumerable<uint16?> values) {
+            values.iterate(i => push_uint16(i));
+        }
+
         public void push_int8(int8 value) {
             var chunk = new uint8[sizeof(int8)];    
             Memory.copy(chunk, &value, sizeof(int8));
             append(ate(chunk));
         }
 
+        public void push_all_int8(Enumerable<int8?> values) {
+            values.iterate(i => push_int8(i));
+        }
+
         public void push_uint8(uint8 value) {
             var chunk = new uint8[] { value };
             append(ate(chunk));
         }
 
+        public void push_all_uint8(Enumerable<uint8?> values) {
+            values.iterate(i => push_uint8(i));
+        }
+
         public string to_escaped_string() {
             var builder = new StringBuilder();
             foreach (var byte in this) {

src/lib/Concrete/Sequence.vala

@@ -9,6 +9,17 @@ namespace Invercargill {
             public SequenceItem(T value) {
                 this.value = value;
             }
+
+            // Carefully unlink sequence items when destructed.
+            // Very large sequences sometimes cause a segfault without this
+            ~SequenceItem() {
+                var n = next;
+                while(n != null) {
+                    var c = n;
+                    n = n.next;
+                    c.next = null;
+                }
+            }
         }
 
         internal SequenceItem<T> root;

src/lib/Queries/Sort.vala

@@ -8,28 +8,11 @@ namespace Invercargill {
             compare_func = (owned)compare;
         }
 
-        //  public override bool iterate_if (Invercargill.PredicateDelegate<T> handler) {
-        //      // Hack for now
-        //      var list = to_collection();
-        //      list.order_by ((a, b) => compare_func(a, b));
-        //      return gte<T>(list).iterate_if(handler);
-        //  }
-
-        private class SortItem<T> {
-            public CompareDelegate<T> compare_func;
-            public T item;
-
-            public SortItem(T item, CompareDelegate<T> func) {
-                this.item = item;
-                compare_func = (a, b) => func(a, b);
-            }
-        }
 
         public override Tracker<T> get_tracker() {
             // Hack for now
-            var list = to_collection();
-            list.order_by ((a, b) => compare_func(a, b));
-            return gte<T>(list).get_tracker();
+            var list = input.to_collection();
+            return new GeeTracker<T>(list, list.order_by ((a, b) => compare_func(a, b)));
         }
     }
 

src/lib/Tracker.vala

@@ -64,4 +64,23 @@ namespace Invercargill {
 
     }
 
+    internal class GeeTracker<T> : Tracker<T> {
+        private Gee.Iterable<T> source;
+        private Gee.Iterator<T> iterator;
+
+        public GeeTracker(Gee.Iterable<T> source, Gee.Iterator<T> iterator) {
+            this.source = source;
+            this.iterator = iterator;
+        }
+
+        public override bool has_next () {
+            return iterator.has_next();
+        }
+        public override T get_next () {
+            iterator.next();
+            var item = iterator.get();
+            return item;
+        }
+    }
+
 }

src/tests/Integration/Sort.vala

@@ -0,0 +1,13 @@
+using Invercargill;
+
+void sort_tests() {
+
+    Test.add_func("/invercargill/operator/sort/ints", () => {
+        var items = ate(new int[] { 8, 5, 6, 9, 10, 2, 7, 1, 4, 3 });
+        var expected = ate(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+
+        var result = items.sort((a, b) => a - b);
+        
+        assert_true(expected.matches(result, (a, b) => a == b));
+    });
+}

src/tests/TestRunner.vala

@@ -11,6 +11,7 @@ public static int main(string[] args) {
     parallel_tests();
     first_tests();
     binary_data_tests();
+    sort_tests();
 
     Test.run();