ToLookup lookup implements ICollection #86

Author: neuecc

src/ZLinq/Linq/ToLookup.cs

@@ -315,7 +315,8 @@ void ResizeAndRehash()
         }
     }
 
-    internal sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>
+    // .NET ILookup implements ICollection
+    internal sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>, ICollection<IGrouping<TKey, TElement>>, IReadOnlyCollection<IGrouping<TKey, TElement>>
     {
         internal static readonly Lookup<TKey, TElement> Empty = new Lookup<TKey, TElement>();
 
@@ -429,6 +430,46 @@ uint InternalGetHashCode(TKey key)
             // allows null.
             return (uint)((key is null) ? 0 : comparer.GetHashCode(key) & 0x7FFFFFFF);
         }
+
+        // ICollection
+
+        bool ICollection<IGrouping<TKey, TElement>>.IsReadOnly => true;
+
+        void ICollection<IGrouping<TKey, TElement>>.Add(IGrouping<TKey, TElement> item) => throw new NotSupportedException();
+        bool ICollection<IGrouping<TKey, TElement>>.Remove(IGrouping<TKey, TElement> item) => throw new NotSupportedException();
+        void ICollection<IGrouping<TKey, TElement>>.Clear() => throw new NotSupportedException();
+
+        bool ICollection<IGrouping<TKey, TElement>>.Contains(IGrouping<TKey, TElement> item)
+        {
+            var group = GetGroup(item.Key);
+            if (group != null && group == item)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        void ICollection<IGrouping<TKey, TElement>>.CopyTo(IGrouping<TKey, TElement>[] array, int arrayIndex)
+        {
+            ArgumentNullException.ThrowIfNull(array);
+            if (arrayIndex < 0) throw new ArgumentOutOfRangeException(nameof(arrayIndex), "Non-negative number required.");
+            if (arrayIndex > array.Length) throw new ArgumentOutOfRangeException(nameof(arrayIndex), "Index was out of range. Must be non-negative and less than the size of the collection.");
+            if (array.Length - arrayIndex < Count)  throw new ArgumentOutOfRangeException(nameof(arrayIndex), "Destination array is not long enough to copy all the items in the collection. Check array index and length.");
+
+            if (last is null) return;
+
+            var group = last.NextGroupInAddOrder; // as first.
+            if (group is null) return;
+
+            var first = group;
+            do
+            {
+                array[arrayIndex] = group;
+                ++arrayIndex;
+
+                group = group.NextGroupInAddOrder;
+            } while (group != null && group != first);
+        }
     }
 
     [DebuggerDisplay("Key = {Key}, ({Count})")]

tests/ZLinq.Tests/Linq/ToLookupTest.cs

@@ -174,4 +174,91 @@ public void ElementSelectorTransformation()
         lookup[3].ShouldBe(new[] { "CCC" });
         lookup[4].ShouldBe(new[] { "DDDD" });
     }
+
+    [Fact]
+    public void ICollectionContains()
+    {
+        var xs = new[] { 1, 2, 3, 4, 5 };
+        var lookup = xs.AsValueEnumerable().ToLookup(x => x);
+
+        // Cast to ICollection to test the explicit interface implementation
+        var collection = (ICollection<IGrouping<int, int>>)lookup;
+
+        // Contains should return true only when the exact same grouping instance is passed
+        foreach (var group in collection)
+        {
+            collection.Contains(group).ShouldBeTrue();
+        }
+
+        // A different grouping with the same key should return false
+        var otherLookup = xs.AsValueEnumerable().ToLookup(x => x);
+        foreach (var group in otherLookup)
+        {
+            collection.Contains(group).ShouldBeFalse();
+        }
+    }
+
+    [Fact]
+    public void ICollectionCopyTo()
+    {
+        var xs = new[] { 1, 2, 3, 4, 5 };
+        var lookup = xs.AsValueEnumerable().ToLookup(x => x);
+
+        // Cast to ICollection to test the explicit interface implementation
+        var collection = (ICollection<IGrouping<int, int>>)lookup;
+
+        // Create array to copy to
+        var array = new IGrouping<int, int>[collection.Count];
+        collection.CopyTo(array, 0);
+
+        // Verify that all elements were copied
+        var i = 0;
+        foreach (var group in lookup)
+        {
+            array[i++].ShouldBe(group);
+        }
+
+        // Test with offset
+        var largerArray = new IGrouping<int, int>[collection.Count + 2];
+        collection.CopyTo(largerArray, 1);
+
+        largerArray[0].ShouldBeNull();
+        i = 0;
+        foreach (var group in lookup)
+        {
+            largerArray[i + 1].ShouldBe(group);
+            i++;
+        }
+        largerArray[collection.Count + 1].ShouldBeNull();
+    }
+
+    [Fact]
+    public void ICollectionCopyToExceptions()
+    {
+        var xs = new[] { 1, 2, 3, 4, 5 };
+        var lookup = xs.AsValueEnumerable().ToLookup(x => x);
+
+        // Cast to ICollection to test the explicit interface implementation
+        var collection = (ICollection<IGrouping<int, int>>)lookup;
+
+        // Should throw when array is null
+        Should.Throw<ArgumentNullException>(() => collection.CopyTo(null!, 0));
+
+        // Should throw when index is negative
+        Should.Throw<ArgumentOutOfRangeException>(() =>
+            collection.CopyTo(new IGrouping<int, int>[collection.Count], -1));
+
+        // Should throw when index is greater than array length
+        Should.Throw<ArgumentOutOfRangeException>(() =>
+            collection.CopyTo(new IGrouping<int, int>[collection.Count], collection.Count + 1));
+
+        // Should throw when array is too small
+        Should.Throw<ArgumentOutOfRangeException>(() =>
+            collection.CopyTo(new IGrouping<int, int>[collection.Count - 1], 0));
+
+        // Should throw when array with offset is too small
+        Should.Throw<ArgumentOutOfRangeException>(() =>
+            collection.CopyTo(new IGrouping<int, int>[collection.Count], 1));
+    }
+
 }