Improve stickies

src/lib/Modifiers/Sealed.vala

@@ -1,6 +1,6 @@
 namespace Invercargill.Modifiers {
 
-    public class Sealed<T> : EnumerableProxy<T> {
+    public class Sealed<T> : Proxy<T> {
 
         public Sealed (Enumerable<T> source) {
             inner = source;

src/lib/Promotions/Attempts.vala

@@ -3,7 +3,7 @@ using Invercargill.Mapping;
 
 namespace Invercargill {
 
-    public class Attempts<T> : EnumerableProxy<Attempt<T>>, Promotion<Attempt<T>> {
+    public class Attempts<T> : Proxy<Attempt<T>>, Promotion<Attempt<T>> {
 
         public Enumerable<Attempt<T>> wrap (Enumerable<Attempt<T>> enumerable) {
             inner = enumerable;

src/lib/Promotions/Equatables.vala

@@ -11,8 +11,8 @@ namespace Invercargill {
             return this;
         }
 
-        protected override Enumerable<T> new_wrap(Enumerable<T> enumerable) {
-            return new Equatables<T>().wrap(enumerable);
+        protected override Equatables<T> rewrap(Enumerable<T> enumerable) {
+            return (Equatables<T>)new Equatables<T>().wrap(enumerable);
         }
 
         public bool equals(Enumerable<T> other) {

src/lib/Promotions/Numbers/Implementations.vala

@@ -1,8 +1,8 @@
 namespace Invercargill {
 
     public class SignedNativeIntegers : Numbers<int, SignedNativeIntegers> {
-        protected override Enumerable<int> new_wrap(Enumerable<int> enumerable) {
-            return new SignedNativeIntegers().wrap(enumerable);
+        protected override SignedNativeIntegers rewrap(Enumerable<int> enumerable) {
+            return (SignedNativeIntegers)new SignedNativeIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(int));
@@ -37,8 +37,8 @@ namespace Invercargill {
     }
 
     public class UnsignedNativeIntegers : Numbers<uint, UnsignedNativeIntegers> {
-        protected override Enumerable<uint> new_wrap(Enumerable<uint> enumerable) {
-            return new UnsignedNativeIntegers().wrap(enumerable);
+        protected override UnsignedNativeIntegers rewrap(Enumerable<uint> enumerable) {
+            return (UnsignedNativeIntegers)new UnsignedNativeIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(uint));
@@ -73,8 +73,8 @@ namespace Invercargill {
     }
 
     public class Signed8BitIntegers : Numbers<int8, Signed8BitIntegers> {
-        protected override Enumerable<int8> new_wrap(Enumerable<int8> enumerable) {
-            return new Signed8BitIntegers().wrap(enumerable);
+        protected override Signed8BitIntegers rewrap(Enumerable<int8> enumerable) {
+            return (Signed8BitIntegers)new Signed8BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(int8));
@@ -109,8 +109,8 @@ namespace Invercargill {
     }
 
     public class Unsigned8BitIntegers : Numbers<uint8, Unsigned8BitIntegers> {
-        protected override Enumerable<uint8> new_wrap(Enumerable<uint8> enumerable) {
-            return new Unsigned8BitIntegers().wrap(enumerable);
+        protected override Unsigned8BitIntegers rewrap(Enumerable<uint8> enumerable) {
+            return (Unsigned8BitIntegers)new Unsigned8BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(uint8));
@@ -145,8 +145,8 @@ namespace Invercargill {
     }
 
     public class Signed16BitIntegers : Numbers<int16, Signed16BitIntegers> {
-        protected override Enumerable<int16> new_wrap(Enumerable<int16> enumerable) {
-            return new Signed16BitIntegers().wrap(enumerable);
+        protected override Signed16BitIntegers rewrap(Enumerable<int16> enumerable) {
+            return (Signed16BitIntegers)new Signed16BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(int16));
@@ -181,8 +181,8 @@ namespace Invercargill {
     }
 
     public class Unsigned16BitIntegers : Numbers<uint16, Unsigned16BitIntegers> {
-        protected override Enumerable<uint16> new_wrap(Enumerable<uint16> enumerable) {
-            return new Unsigned16BitIntegers().wrap(enumerable);
+        protected override Unsigned16BitIntegers rewrap(Enumerable<uint16> enumerable) {
+            return (Unsigned16BitIntegers)new Unsigned16BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(uint16));
@@ -217,8 +217,8 @@ namespace Invercargill {
     }
 
     public class Signed32BitIntegers : Numbers<int32, Signed32BitIntegers> {
-        protected override Enumerable<int32> new_wrap(Enumerable<int32> enumerable) {
-            return new Signed32BitIntegers().wrap(enumerable);
+        protected override Signed32BitIntegers rewrap(Enumerable<int32> enumerable) {
+            return (Signed32BitIntegers)new Signed32BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(int32));
@@ -253,8 +253,8 @@ namespace Invercargill {
     }
 
     public class Unsigned32BitIntegers : Numbers<uint32, Unsigned32BitIntegers> {
-        protected override Enumerable<uint32> new_wrap(Enumerable<uint32> enumerable) {
-            return new Unsigned32BitIntegers().wrap(enumerable);
+        protected override Unsigned32BitIntegers rewrap(Enumerable<uint32> enumerable) {
+            return (Unsigned32BitIntegers)new Unsigned32BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(uint32));
@@ -289,8 +289,8 @@ namespace Invercargill {
     }
 
     public class Signed64BitIntegers : Numbers<int64?, Signed64BitIntegers> {
-        protected override Enumerable<int64?> new_wrap(Enumerable<int64?> enumerable) {
-            return new Signed64BitIntegers().wrap(enumerable);
+        protected override Signed64BitIntegers rewrap(Enumerable<int64?> enumerable) {
+            return (Signed64BitIntegers)new Signed64BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(int64?));
@@ -325,8 +325,8 @@ namespace Invercargill {
     }
 
     public class Unsigned64BitIntegers : Numbers<uint64?, Unsigned64BitIntegers> {
-        protected override Enumerable<uint64?> new_wrap(Enumerable<uint64?> enumerable) {
-            return new Unsigned64BitIntegers().wrap(enumerable);
+        protected override Unsigned64BitIntegers rewrap(Enumerable<uint64?> enumerable) {
+            return (Unsigned64BitIntegers)new Unsigned64BitIntegers().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(uint64?));
@@ -361,8 +361,8 @@ namespace Invercargill {
     }
 
     public class Doubles : Numbers<double?, Doubles> {
-        protected override Enumerable<double?> new_wrap(Enumerable<double?> enumerable) {
-            return new Doubles().wrap(enumerable);
+        protected override Doubles rewrap(Enumerable<double?> enumerable) {
+            return (Doubles)new Doubles().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(double?));
@@ -397,8 +397,8 @@ namespace Invercargill {
     }
 
     public class Floats : Numbers<float?, Floats> {
-        protected override Enumerable<float?> new_wrap(Enumerable<float?> enumerable) {
-            return new Floats().wrap(enumerable);
+        protected override Floats rewrap(Enumerable<float?> enumerable) {
+            return (Floats)new Floats().wrap(enumerable);
         }
         public override bool can_wrap(GLib.Type element_type) {
             return element_type.is_a(typeof(float?));

src/lib/Promotions/PropertyGroups.vala

@@ -9,8 +9,8 @@ namespace Invercargill {
             return this;
         }
 
-        protected override Enumerable<Properties> new_wrap(Enumerable<Properties> enumerable) {
-            return new PropertyGroups().wrap(enumerable);
+        protected override PropertyGroups rewrap(Enumerable<Properties> enumerable) {
+            return (PropertyGroups)new PropertyGroups().wrap(enumerable);
         }
 
         public override bool can_wrap (GLib.Type element_type) {

src/lib/EnumerableProxy.vala → src/lib/Proxy.vala

@@ -3,7 +3,7 @@ using Invercargill.Mapping;
 
 namespace Invercargill {
 
-    public abstract class EnumerableProxy<T> : Enumerable<T> {
+    public abstract class Proxy<T> : Enumerable<T> {
 
         protected Enumerable<T> inner { get; set; }
 

src/lib/StickyPromotion.vala

@@ -1,53 +1,11 @@
 namespace Invercargill {
 
-    public abstract class StickyPromotion<T, TPromotion> : EnumerableProxy<T>, Promotion<T> {
+    public abstract class StickyPromotion<T, TPromotion> : StickyProxy<TPromotion, T>, Promotion<T> {
 
         public abstract Enumerable<T> wrap(Enumerable<T> enumerable);
-        protected abstract Enumerable<T> new_wrap(Enumerable<T> enumerable);
         public abstract bool can_wrap(GLib.Type element_type);
 
-        public new TPromotion where(owned PredicateDelegate<T> predicate) {
-            return (TPromotion)new_wrap(inner.where((owned)predicate));
-        }
-    
-        public new TPromotion sort(owned CompareDelegate<T> compare) {
-            return (TPromotion)new_wrap(inner.sort((owned)compare));
-        }
-    
-        public new TPromotion concat(Enumerable<T> other) {
-            return (TPromotion)new_wrap(inner.concat(other));
-        }
-    
-        public new TPromotion take(int count) {
-            return (TPromotion)new_wrap(inner.take(count));
-        }
-    
-        public new TPromotion skip(int count) {
-            return (TPromotion)new_wrap(inner.skip(count));
-        }
-    
-        public new TPromotion with(T item, uint times = 1) {
-            return (TPromotion)new_wrap(inner.with(item, times));
-        }
-    
-        public new TPromotion seal() {
-            return (TPromotion)new_wrap(inner.seal());
-        }
-
-        public new TPromotion cache() {
-            return (TPromotion)new_wrap(inner.cache());
-        }
-
-        public new TPromotion act(ItemDelegate<T> handler) {
-            return (TPromotion)new_wrap(inner.act(handler));
-        }
-
-        public new TPromotion debug_trace(string additional_message = "", owned StringifyDelegate<T>? stringifier = null, owned DebugOutputDelegate? output_func = null, bool formatting = true) {
-            return (TPromotion)new_wrap(new TraceEnumerable<T>(this, get_info(), (owned)stringifier, additional_message, (owned)output_func, formatting));
-        }
-
-        public new TPromotion debug_type(string additional_message = "", DebugOutputDelegate? output_func = null, bool formatting = true) {
-            DebugPrinter.print_enumerable_information(get_info(), additional_message, output_func, formatting);
+        public override TPromotion recycle() {
             return (TPromotion)wrap(inner);
         }
     }

src/lib/StickyProxy.vala

@@ -0,0 +1,58 @@
+using Invercargill.DataStructures;
+using Invercargill.Mapping;
+
+namespace Invercargill {
+
+    public abstract class StickyProxy<TEnumerable, T> : Proxy<T> {
+
+        protected abstract TEnumerable rewrap(Enumerable<T> enumerable);
+        protected abstract TEnumerable recycle();
+
+        public new TEnumerable where(owned PredicateDelegate<T> predicate) {
+            return rewrap(inner.where((owned)predicate));
+        }
+    
+        public new TEnumerable sort(owned CompareDelegate<T> compare) {
+            return rewrap(inner.sort((owned)compare));
+        }
+    
+        public new TEnumerable concat(Enumerable<T> other) {
+            return rewrap(inner.concat(other));
+        }
+    
+        public new TEnumerable take(int count) {
+            return rewrap(inner.take(count));
+        }
+    
+        public new TEnumerable skip(int count) {
+            return rewrap(inner.skip(count));
+        }
+    
+        public new TEnumerable with(T item, uint times = 1) {
+            return rewrap(inner.with(item, times));
+        }
+    
+        public new TEnumerable seal() {
+            return rewrap(inner.seal());
+        }
+
+        public new TEnumerable cache() {
+            return rewrap(inner.cache());
+        }
+
+        public new TEnumerable act(ItemDelegate<T> handler) {
+            return rewrap(inner.act(handler));
+        }
+
+        public new TEnumerable debug_trace(string additional_message = "", owned StringifyDelegate<T>? stringifier = null, owned DebugOutputDelegate? output_func = null, bool formatting = true) {
+            return rewrap(new TraceEnumerable<T>(this, get_info(), (owned)stringifier, additional_message, (owned)output_func, formatting));
+        }
+
+        public new TEnumerable debug_type(string additional_message = "", DebugOutputDelegate? output_func = null, bool formatting = true) {
+            DebugPrinter.print_enumerable_information(get_info(), additional_message, output_func, formatting);
+            return recycle();
+        }
+
+    }
+
+}

src/lib/meson.build

@@ -22,7 +22,8 @@ sources += files('Interfaces.vala')
 sources += files('KeyValuePair.vala')
 sources += files('Attempt.vala')
 sources += files('Cache.vala')
-sources += files('EnumerableProxy.vala')
+sources += files('Proxy.vala')
+sources += files('StickyProxy.vala')
 sources += files('EnumerableInfo.vala')
 sources += files('StickyPromotion.vala')
 sources += files('Element.vala')