refactor(grouping): make Grouping inherit from Proxy

The Grouping class now inherits from Proxy<TItems> to simplify its
implementation. The items field has been removed in favor of
delegation through the Proxy base class.

BREAKING CHANGE: The public items field has been removed. Use the
enumeration methods directly on the Grouping object instead.

src/lib/Grouping.vala

@@ -1,21 +1,12 @@
 
 namespace Invercargill {
 
-    [Compact]
-    [Immutable]
-    [CCode (copy_function = "invercargill_grouping_copy")]
-    public class Grouping<TKey, TItems> {
-
-        public TKey key;
-        public Enumerable<TItems> items;
+    public class Grouping<TKey, TItems> : Proxy<TItems> {
 
+        public TKey key { get; private set; }
         public Grouping(TKey key, Enumerable<TItems> items) {
             this.key = key;
-            this.items = items;
-        }
-
-        public Grouping<TKey, TItems> copy() {
-            return new Grouping<TKey, TItems>(key, items);
+            this.inner = items;
         }
     }
 

src/lib/Interfaces/Grouped.vala

@@ -0,0 +1,6 @@
+
+namespace Invercargill {
+
+    
+
+}

src/lib/Interfaces/ReadOnlyGrouped.vala

@@ -0,0 +1,34 @@
+
+namespace Invercargill {
+
+    [GenericAccessors]
+    public interface ReadOnlyGrouped<TKey, TValue> : ReadOnlyAssociative<TKey, Group<TKey, TValue>> {
+        public abstract bool try_get_any(TKey key, out TValue value);
+        public abstract Enumerable<TValue> flat_values { owned get; }
+
+        public virtual TValue get_any(TKey key) throws IndexError {
+            TValue value;
+            if(try_get_any(key, out value)) {
+                return value;
+            }
+            throw new IndexError.KEY_NOT_FOUND(@"Key not found in the associative collection");
+        }
+        
+        public virtual TValue? get_any_or_default(TKey key) {
+            TValue value;
+            if(try_get_any(key, out value)) {
+                return value;
+            }
+            return null;
+        }
+
+        public virtual Enumerable<Group<TKey, TValue>> get_or_empty(TKey key) {
+            Enumerable<Group<TKey, TValue>> value;
+            if(try_get_any(key, out value)) {
+                return value;
+            }
+            return null;
+        }
+    }
+
+}

src/tests/Integration/EnumerableMethods.vala

@@ -518,8 +518,8 @@ void enumerable_methods_tests() {
         assert(result.length == 2);
         var group25 = result[0].key == 25 ? result[0] : result[1];
         var group30 = result[0].key == 30 ? result[0] : result[1];
-        assert(group25.items.count() == 2);
-        assert(group30.items.count() == 2);
+        assert(group25.count() == 2);
+        assert(group30.count() == 2);
     });
 
     Test.add_func("/invercargill/enumerable/histogram", () => {
@@ -737,16 +737,16 @@ void enumerable_methods_tests() {
 
     Test.add_func("/invercargill/enumerable/group_adjacent_by", () => {
         var items = Wrap.array(new int[] { 1, 1, 2, 3, 3, 3, 2, 2 });
-        var result = items.group_adjacent_by<int>(i => i).debug_trace("SEQ", s => @"$(s.key): $(s.items.count())").to_array();
+        var result = items.group_adjacent_by<int>(i => i).debug_trace("SEQ", s => @"$(s.key): $(s.count())").to_array();
         assert(result.length == 4);
         assert(result[0].key == 1);
-        assert(result[0].items.count() == 2);
+        assert(result[0].count() == 2);
         assert(result[1].key == 2);
-        assert(result[1].items.count() == 1);
+        assert(result[1].count() == 1);
         assert(result[2].key == 3);
-        assert(result[2].items.count() == 3);
+        assert(result[2].count() == 3);
         assert(result[3].key == 2);
-        assert(result[3].items.count() == 2);
+        assert(result[3].count() == 2);
     });
 
     Test.add_func("/invercargill/enumerable/window", () => {

src/tests/Integration/Modifiers.vala

@@ -49,13 +49,13 @@ void modifiers_tests() {
         var result = items.group_adjacent_by<int>(i => i).to_array();
         assert(result.length == 4);
         assert(result[0].key == 1);
-        assert(result[0].items.count() == 2);
+        assert(result[0].count() == 2);
         assert(result[1].key == 2);
-        assert(result[1].items.count() == 1);
+        assert(result[1].count() == 1);
         assert(result[2].key == 3);
-        assert(result[2].items.count() == 3);
+        assert(result[2].count() == 3);
         assert(result[3].key == 2);
-        assert(result[3].items.count() == 2);
+        assert(result[3].count() == 2);
     });
 
     Test.add_func("/invercargill/modifiers/interleave/simple", () => {