Add initial implemenation of Span<> class

Author: josesimoes

Tests/NFUnitTestTypes/UnitTestsSpanByte.cs

@@ -13,67 +13,67 @@ public class UnitTestsSpanByte
         public void EmptySpanTests()
         {
             // Empty span
-            SpanByte span = SpanByte.Empty;
+            Span span = Span.Empty;
             // Create a destination span larger
-            SpanByte destination = new byte[1];
+            Span destination = new byte[1];
             span.CopyTo(destination);
 
             // Now also empty
-            destination = SpanByte.Empty;
+            destination = Span.Empty;
             span.CopyTo(destination);
         }
 
         [TestMethod]
         public void RaisingExceptionsOfAllKindsTests()
         {
             // Should raise an exception on creation
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0");
 
             // Exception on index access
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var data = span[span.Length];
             });
             Assert.ThrowsException(typeof(IndexOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var data = span[-1];
             });
 
             // Copy to with too small destination
             Assert.ThrowsException(typeof(ArgumentException), () =>
             {
-                SpanByte span = new SpanByte(array);
-                SpanByte destination = new byte[span.Length - 1];
+                Span span = new Span(array);
+                Span destination = new byte[span.Length - 1];
                 span.CopyTo(destination);
             });
 
             // Slicing arguments
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(span.Length + 1);
             });
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(1, span.Length);
             });
 
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(-1, span.Length);
             });
 
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(1, -1);
             });
 
@@ -84,7 +84,7 @@ public void ToArrayTest()
         {
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
 
-            SpanByte span = new(array);
+            Span span = new(array);
 
             byte[] toArray = span.ToArray();
 
@@ -95,28 +95,28 @@ public void ToArrayTest()
         public void ConstructorsOfAllKindsTests()
         {
             // Empty span
-            SpanByte span = new SpanByte();
+            Span span = new Span();
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Empty span
-            span = new SpanByte(null, 0, 0);
+            span = new Span(null, 0, 0);
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Empty span
-            span = SpanByte.Empty;
+            span = Span.Empty;
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            span = new SpanByte(array);
+            span = new Span(array);
             Assert.AreEqual(span.Length, array.Length, $"SpanByte should have length of the array it takes: {array.Length}");
             Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty");
 
             // Span from normal array with different start and length
-            span = new SpanByte(array, 2, 8);
+            span = new Span(array, 2, 8);
             Assert.AreEqual(span.Length, 8, $"SpanByte should have length of 8");
             Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty");
         }
@@ -126,7 +126,7 @@ public void SliceTests()
         {
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             // Slice 2 elements and check
             var sliced = span.Slice(0, 2);
             Assert.AreEqual(sliced.Length, 2, "Sliced span lenght must be 2");
@@ -167,9 +167,9 @@ public void SliceTests()
         public void CopyToTests()
         {
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             // First a copy to with the full span
-            SpanByte toCopy = new byte[span.Length];
+            Span toCopy = new byte[span.Length];
             span.CopyTo(toCopy);
             for (int i = 0; i < span.Length; i++)
             {
@@ -192,14 +192,14 @@ public void GetElementsTests()
         {
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             for (int i = 0; i < span.Length; i++)
             {
                 Assert.AreEqual(span[i], array[i], "SpanByte value should be the same as from the original array");
             }
 
             // Partial span
-            span = new SpanByte(array, 2, 8);
+            span = new Span(array, 2, 8);
             for (int i = 0; i < span.Length; i++)
             {
                 Assert.AreEqual(span[i], array[i + 2], "SpanByte value should be the same as from the original array");
@@ -210,7 +210,7 @@ public void GetElementsTests()
         public void SetElementsTests()
         {
             // Create a span, and set the data
-            SpanByte span = new byte[12];
+            Span span = new byte[12];
             // All should be 0
             for (int i = 0; i < span.Length; i++)
             {

nanoFramework.CoreLibrary/CoreLibrary.nfproj

@@ -191,7 +191,9 @@
     <Compile Include="System\SByte.cs" />
     <Compile Include="System\SerializableAttribute.cs" />
     <Compile Include="System\Single.cs" />
-    <Compile Include="System\SpanByte.cs" />
+    <Compile Include="System\ReadOnlySpan.cs" />
+    <Compile Include="System\SpanDebugView.cs" />
+    <Compile Include="System\Span.cs" />
     <Compile Include="System\String.cs" />
     <Compile Include="System\SystemException.cs" />
     <Compile Include="System\TargetFrameworkAttribute.cs" />
@@ -254,4 +256,4 @@
   <Import Project="..\packages\Microsoft.SourceLink.Common.1.1.1\build\Microsoft.SourceLink.Common.targets" Condition="Exists('..\packages\Microsoft.SourceLink.Common.1.1.1\build\Microsoft.SourceLink.Common.targets')" />
   <Import Project="..\packages\Microsoft.SourceLink.GitHub.1.1.1\build\Microsoft.SourceLink.GitHub.targets" Condition="Exists('..\packages\Microsoft.SourceLink.GitHub.1.1.1\build\Microsoft.SourceLink.GitHub.targets')" />
   <Import Project="..\packages\Nerdbank.GitVersioning.3.7.115\build\Nerdbank.GitVersioning.targets" Condition="Exists('..\packages\Nerdbank.GitVersioning.3.7.115\build\Nerdbank.GitVersioning.targets')" />
-</Project>
+</Project>

nanoFramework.CoreLibrary/System/ReadOnlySpan.cs

@@ -0,0 +1,151 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+
+#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one 
+
+namespace System
+{
+    /// <summary>
+    /// <see cref="ReadOnlySpan"/> represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
+    /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe.
+    /// </summary>
+    [DebuggerTypeProxy(typeof(SpanDebugView<>))]
+    [DebuggerDisplay("{ToString(),raw}")]
+    public readonly ref struct ReadOnlySpan<T>
+    {
+        private readonly T[] _array;
+        private readonly int _start;
+        private readonly int _length;
+
+        /// <summary>
+        /// Creates a new read-only span over the entirety of the target array.
+        /// </summary>
+        /// <param name="array">The target array.</param>
+        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        public ReadOnlySpan(T[]? array)
+        {
+            _array = array ?? Array.Empty<T>();
+            _start = 0;
+            _length = _array.Length;
+        }
+
+        /// <summary>
+        /// Creates a new read-only span over the portion of the target array beginning
+        /// at 'start' index and ending at 'end' index (exclusive).
+        /// </summary>
+        /// <param name="array">The target array.</param>
+        /// <param name="start">The zero-based index at which to begin the read-only span.</param>
+        /// <param name="length">The number of items in the read-only span.</param>
+        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;Length).
+        /// </exception>
+        public ReadOnlySpan(T[]? array, int start, int length)
+        {
+            if (array == null)
+            {
+                if (start != 0 || length != 0)
+                {
+                    throw new ArgumentOutOfRangeException();
+                }
+
+                _array = Array.Empty<T>();
+                _start = 0;
+                _length = 0;
+
+                return;
+            }
+
+            if ((uint)start > (uint)array.Length
+                || (uint)length > (uint)(array.Length - start))
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+
+            _array = array;
+            _start = start;
+            _length = length;
+        }
+
+        /// <summary>
+        /// Returns the specified element of the read-only span.
+        /// </summary>
+        /// <param name="index">The zero-based index.</param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to Length
+        /// </exception>
+        public ref readonly T this[int index]
+        {
+            get
+            {
+                if ((uint)index >= (uint)_length)
+                {
+                    throw new ArgumentOutOfRangeException();
+                }
+
+                return ref _array[_start + index];
+            }
+        }
+
+        /// <summary>
+        /// The number of items in the read-only span.
+        /// </summary>
+        public int Length => _length;
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="Span{T}"/> is empty.
+        /// </summary>
+        /// <value><see langword="true"/> if this span is empty; otherwise, <see langword="false"/>.</value>
+        public bool IsEmpty => _length == 0;
+
+        /// <summary>
+        /// Returns false if left and right point at the same memory and have the same length.  Note that
+        /// this does *not* check to see if the *contents* are equal.
+        /// </summary>
+        public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right) => !(left == right);
+
+        /// <summary>
+        /// Defines an implicit conversion of an array to a <see cref="ReadOnlySpan{T}"/>
+        /// </summary>
+        public static implicit operator ReadOnlySpan<T>(T[]? array) => new ReadOnlySpan<T>(array);
+
+        /// <summary>
+        /// Returns true if left and right point at the same memory and have the same length.  Note that
+        /// this does *not* check to see if the *contents* are equal.
+        /// </summary>
+        public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right)
+        {
+            if (left.Length != right.Length)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < left.Length; i++)
+            {
+                if (!Equals(left[i], right[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Copies the contents of this read-only span into a new array.  This heap
+        /// allocates, so should generally be avoided, however it is sometimes
+        /// necessary to bridge the gap with APIs written in terms of arrays.
+        /// </summary>
+        public T[] ToArray()
+        {
+            T[] destination = new T[_length];
+            Array.Copy(_array, _start, destination, 0, _length);
+            return destination;
+        }
+    }
+}
+
+#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one