apacheGH-38692: [C#] Implement ICollection<T?> on scalar arrays (apac…

…he#41539) ### What changes are included in this PR? This PR makes the following array types support ICollection<T?> : - PrimitiveArray - BooleanArray - Date32Array - Date64Array - Time32Array - Time64Array - BinaryArray - TimestampArray - StringArray ### Are these changes tested? Yes ### Are there any user-facing changes? No Closes apache#38692 * GitHub Issue: apache#38692 Authored-by: voidstar69 <[email protected]> Signed-off-by: Curt Hagenlocher <[email protected]>
CurtHagenlocher · May 13, 2024 · a715ea0 · a715ea0
1 parent 875e4df
commit a715ea0
Show file tree

Hide file tree

Showing 17 changed files with 450 additions and 40 deletions.
diff --git a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
@@ -22,7 +22,7 @@
 
 namespace Apache.Arrow
 {
-    public class BinaryArray : Array, IReadOnlyList<byte[]>
+    public class BinaryArray : Array, IReadOnlyList<byte[]>, ICollection<byte[]>
     {
         public class Builder : BuilderBase<BinaryArray, Builder>
         {
@@ -380,5 +380,30 @@ IEnumerator<byte[]> IEnumerable<byte[]>.GetEnumerator()
         }
 
         IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<byte[]>)this).GetEnumerator();
+
+        int ICollection<byte[]>.Count => Length;
+        bool ICollection<byte[]>.IsReadOnly => true;
+        void ICollection<byte[]>.Add(byte[]? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<byte[]>.Remove(byte[]? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<byte[]>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<byte[]>.Contains(byte[] item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetBytes(index).SequenceEqual(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<byte[]>.CopyTo(byte[][] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetBytes(srcIndex).ToArray();
+            }
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/BooleanArray.cs b/csharp/src/Apache.Arrow/Arrays/BooleanArray.cs
@@ -21,7 +21,7 @@
 
 namespace Apache.Arrow
 {
-    public class BooleanArray: Array, IReadOnlyList<bool?>
+    public class BooleanArray: Array, IReadOnlyList<bool?>, ICollection<bool?>
     {
         public class Builder : IArrowArrayBuilder<bool, BooleanArray, Builder>
         {
@@ -188,7 +188,7 @@ public bool GetBoolean(int index)
         public bool? GetValue(int index)
         {
             return IsNull(index)
-                ? (bool?)null
+                ? null
                 : BitUtility.GetBit(ValueBuffer.Span, index + Offset);
         }
 
@@ -205,5 +205,30 @@ public bool GetBoolean(int index)
         }
 
         IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<bool?>)this).GetEnumerator();
+
+        int ICollection<bool?>.Count => Length;
+        bool ICollection<bool?>.IsReadOnly => true;
+        void ICollection<bool?>.Add(bool? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<bool?>.Remove(bool? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<bool?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<bool?>.Contains(bool? item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetValue(index).Equals(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<bool?>.CopyTo(bool?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetValue(srcIndex);
+            }
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/Date32Array.cs b/csharp/src/Apache.Arrow/Arrays/Date32Array.cs
@@ -23,9 +23,9 @@ namespace Apache.Arrow
     /// The <see cref="Date32Array"/> class holds an array of dates in the <c>Date32</c> format, where each date is
     /// stored as the number of days since the dawn of (UNIX) time.
     /// </summary>
-    public class Date32Array : PrimitiveArray<int>, IReadOnlyList<DateTime?>
+    public class Date32Array : PrimitiveArray<int>, IReadOnlyList<DateTime?>, ICollection<DateTime?>
 #if NET6_0_OR_GREATER
-        , IReadOnlyList<DateOnly?>
+        , IReadOnlyList<DateOnly?>, ICollection<DateOnly?>
 #endif
     {
         private static readonly DateTime _epochDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
@@ -40,10 +40,9 @@ public class Builder : DateArrayBuilder<int, Date32Array, Builder>
         {
             private class DateBuilder : PrimitiveArrayBuilder<int, Date32Array, DateBuilder>
             {
-                protected override Date32Array Build(
-                    ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
-                    int length, int nullCount, int offset) =>
-                    new Date32Array(valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+                protected override Date32Array Build(ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer, int length,
+                    int nullCount, int offset) =>
+                    new(valueBuffer, nullBitmapBuffer, length, nullCount, offset);
             }
 
             /// <summary>
@@ -149,6 +148,31 @@ public Date32Array(ArrayData data)
                 yield return GetDateOnly(index);
             };
         }
+
+        int ICollection<DateOnly?>.Count => Length;
+        bool ICollection<DateOnly?>.IsReadOnly => true;
+        void ICollection<DateOnly?>.Add(DateOnly? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<DateOnly?>.Remove(DateOnly? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<DateOnly?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<DateOnly?>.Contains(DateOnly? item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetDateOnly(index).Equals(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<DateOnly?>.CopyTo(DateOnly?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetDateOnly(srcIndex);
+            }
+        }
 #endif
 
         int IReadOnlyCollection<DateTime?>.Count => Length;
@@ -160,7 +184,32 @@ public Date32Array(ArrayData data)
             for (int index = 0; index < Length; index++)
             {
                 yield return GetDateTime(index);
-            };
+            }
+        }
+
+        int ICollection<DateTime?>.Count => Length;
+        bool ICollection<DateTime?>.IsReadOnly => true;
+        void ICollection<DateTime?>.Add(DateTime? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<DateTime?>.Remove(DateTime? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<DateTime?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<DateTime?>.Contains(DateTime? item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetDateTime(index).Equals(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<DateTime?>.CopyTo(DateTime?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetDateTime(srcIndex);
+            }
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/Date64Array.cs b/csharp/src/Apache.Arrow/Arrays/Date64Array.cs
@@ -24,9 +24,9 @@ namespace Apache.Arrow
     /// stored as the number of milliseconds since the dawn of (UNIX) time, excluding leap seconds, in multiples of
     /// 86400000.
     /// </summary>
-    public class Date64Array : PrimitiveArray<long>, IReadOnlyList<DateTime?>
+    public class Date64Array : PrimitiveArray<long>, IReadOnlyList<DateTime?>, ICollection<DateTime?>
 #if NET6_0_OR_GREATER
-        , IReadOnlyList<DateOnly?>
+        , IReadOnlyList<DateOnly?>, ICollection<DateOnly?>
 #endif
     {
         private const long MillisecondsPerDay = 86400000;
@@ -45,10 +45,9 @@ public class Builder : DateArrayBuilder<long, Date64Array, Builder>
         {
             private class DateBuilder : PrimitiveArrayBuilder<long, Date64Array, DateBuilder>
             {
-                protected override Date64Array Build(
-                    ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
-                    int length, int nullCount, int offset) =>
-                    new Date64Array(valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+                protected override Date64Array Build(ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer, int length,
+                    int nullCount, int offset) =>
+                    new(valueBuffer, nullBitmapBuffer, length, nullCount, offset);
             }
 
             /// <summary>
@@ -151,6 +150,31 @@ public Date64Array(ArrayData data)
                 yield return GetDateOnly(index);
             };
         }
+
+        int ICollection<DateOnly?>.Count => Length;
+        bool ICollection<DateOnly?>.IsReadOnly => true;
+        void ICollection<DateOnly?>.Add(DateOnly? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<DateOnly?>.Remove(DateOnly? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<DateOnly?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<DateOnly?>.Contains(DateOnly? item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetDateOnly(index).Equals(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<DateOnly?>.CopyTo(DateOnly?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetDateOnly(srcIndex);
+            }
+        }
 #endif
 
         int IReadOnlyCollection<DateTime?>.Count => Length;
@@ -162,7 +186,32 @@ public Date64Array(ArrayData data)
             for (int index = 0; index < Length; index++)
             {
                 yield return GetDateTime(index);
-            };
+            }
+        }
+
+        int ICollection<DateTime?>.Count => Length;
+        bool ICollection<DateTime?>.IsReadOnly => true;
+        void ICollection<DateTime?>.Add(DateTime? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<DateTime?>.Remove(DateTime? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<DateTime?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<DateTime?>.Contains(DateTime? item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetDateTime(index).Equals(item))
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<DateTime?>.CopyTo(DateTime?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetDateTime(srcIndex);
+            }
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/IntervalArray.cs b/csharp/src/Apache.Arrow/Arrays/IntervalArray.cs
@@ -31,7 +31,7 @@ internal static class IntervalArray
     }
 
     public abstract class IntervalArray<T> : PrimitiveArray<T>
-        where T : struct
+        where T : struct, IEquatable<T>
     {
         protected IntervalArray(ArrayData data)
             : base(data)

diff --git a/csharp/src/Apache.Arrow/Arrays/PrimitiveArray.cs b/csharp/src/Apache.Arrow/Arrays/PrimitiveArray.cs
@@ -20,8 +20,8 @@
 
 namespace Apache.Arrow
 {
-    public abstract class PrimitiveArray<T> : Array, IReadOnlyList<T?>
-        where T : struct
+    public abstract class PrimitiveArray<T> : Array, IReadOnlyList<T?>, ICollection<T?>
+        where T : struct, IEquatable<T>
     {
         protected PrimitiveArray(ArrayData data)
             : base(data)
@@ -40,7 +40,7 @@ protected PrimitiveArray(ArrayData data)
             {
                 throw new ArgumentOutOfRangeException(nameof(index));
             }
-            return IsValid(index) ? Values[index] : (T?)null;
+            return IsValid(index) ? Values[index] : null;
         }
 
         public IList<T?> ToList(bool includeNulls = false)
@@ -86,5 +86,36 @@ IEnumerator IEnumerable.GetEnumerator()
                 yield return IsValid(index) ? Values[index] : null;
             }
         }
+
+        int ICollection<T?>.Count => Length;
+        bool ICollection<T?>.IsReadOnly => true;
+        void ICollection<T?>.Add(T? item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<T?>.Remove(T? item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<T?>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<T?>.Contains(T? item)
+        {
+            if (item == null)
+            {
+                return NullCount > 0;
+            }
+
+            ReadOnlySpan<T> values = Values;
+            while (values.Length > 0)
+            {
+                int index = Values.IndexOf(item.Value);
+                if (index < 0 || IsValid(index)) { return index >= 0; }
+                values = values.Slice(index + 1);
+            }
+            return false;
+        }
+
+        void ICollection<T?>.CopyTo(T?[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetValue(srcIndex);
+            }
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs
@@ -20,7 +20,7 @@
 
 namespace Apache.Arrow
 {
-    public abstract class PrimitiveArrayBuilder<TFrom, TTo, TArray, TBuilder> : IArrowArrayBuilder<TArray, TBuilder>
+    public abstract class PrimitiveArrayBuilder<TFrom, TTo, TArray, TBuilder> : IArrowArrayBuilder<TFrom, TArray, TBuilder>
         where TTo : struct
         where TArray : IArrowArray
         where TBuilder : class, IArrowArrayBuilder<TArray>

diff --git a/csharp/src/Apache.Arrow/Arrays/StringArray.cs b/csharp/src/Apache.Arrow/Arrays/StringArray.cs
@@ -22,7 +22,7 @@
 
 namespace Apache.Arrow
 {
-    public class StringArray: BinaryArray, IReadOnlyList<string>
+    public class StringArray: BinaryArray, IReadOnlyList<string>, ICollection<string>
     {
         public static readonly Encoding DefaultEncoding = Encoding.UTF8;
 
@@ -164,5 +164,30 @@ IEnumerator<string> IEnumerable<string>.GetEnumerator()
         }
 
         IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<string>)this).GetEnumerator();
+
+        int ICollection<string>.Count => Length;
+        bool ICollection<string>.IsReadOnly => true;
+        void ICollection<string>.Add(string item) => throw new NotSupportedException("Collection is read-only.");
+        bool ICollection<string>.Remove(string item) => throw new NotSupportedException("Collection is read-only.");
+        void ICollection<string>.Clear() => throw new NotSupportedException("Collection is read-only.");
+
+        bool ICollection<string>.Contains(string item)
+        {
+            for (int index = 0; index < Length; index++)
+            {
+                if (GetString(index) == item)
+                    return true;
+            }
+
+            return false;
+        }
+
+        void ICollection<string>.CopyTo(string[] array, int arrayIndex)
+        {
+            for (int srcIndex = 0, destIndex = arrayIndex; srcIndex < Length; srcIndex++, destIndex++)
+            {
+                array[destIndex] = GetString(srcIndex);
+            }
+        }
     }
 }