[Select] Introduce SelectCollection

Author: reegeek

src/StructLinq.BCL/List/BCLStructEnumerable.Select.ToList.cs

@@ -0,0 +1,27 @@
+using StructLinq.Array;
+using StructLinq.Select;
+
+namespace StructLinq.Tests
+{
+    public class RefSelectCollectionTests : AbstractCollectionTests<double,
+        RefSelectCollection<int, double, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, RefSelectCollectionTests.MultFunction>,
+        RefSelectEnumerator<int, double, ArrayRefStructEnumerator<int>, RefSelectCollectionTests.MultFunction>>
+    {
+
+        protected override RefSelectCollection<int, double, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, RefSelectCollectionTests.MultFunction> Build(int size)
+        {
+            var func = new MultFunction();
+            var selectEnumerable = 
+                StructEnumerable.Range(-1, size).ToArray().ToRefStructEnumerable().Select(ref func, x=>x, x => x);
+            return selectEnumerable;
+        }
+
+        public struct MultFunction : IInFunction<int, double>
+        {
+            public double Eval(in int element)
+            {
+                return element * 2.0;
+            }
+        }
+    }
+}

src/StructLinq.Tests/RefSelectCollectionTests.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq;
+using StructLinq.Range;
+using StructLinq.Select;
+using Xunit;
+
+namespace StructLinq.Tests
+{
+    public class SelectCollectionFuncTests : AbstractCollectionTests<double,
+        SelectCollection<int, double, RangeEnumerable, RangeEnumerator>,
+        SelectEnumerator<int, double, RangeEnumerator>>
+    {
+        [Fact]
+        public void DelegateTest()
+        {
+            Func<int, double> selector = x => x * 2.0;
+            var sys = Enumerable
+                .Range(-50, 100)
+                .Select(selector)
+                .ToArray();
+            var structEnum = StructEnumerable
+                .Range(-50, 100)
+                .Select(selector)
+                .ToEnumerable()
+                .ToArray();
+            Assert.Equal(sys, structEnum);
+        }
+
+        protected override SelectCollection<int, double, RangeEnumerable, RangeEnumerator> Build(int size)
+        {
+            var selectEnumerable = 
+                StructEnumerable.Range(-1, size).Select(x=> x * 2.0, x=> x);
+            return selectEnumerable;
+        }
+
+    }
+}

src/StructLinq.Tests/SelectCollectionFuncTests.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Linq;
+using StructLinq.Range;
+using StructLinq.Select;
+using Xunit;
+
+namespace StructLinq.Tests
+{
+    public class SelectCollectionTests : AbstractCollectionTests<double,
+        SelectCollection<int, double, RangeEnumerable, RangeEnumerator, MultFunction>,
+        SelectEnumerator<int, double, RangeEnumerator, MultFunction>>
+    {
+        [Fact]
+        public void DelegateTest()
+        {
+            Func<int, double> selector = x => x * 2.0;
+            var sys = Enumerable
+                .Range(-50, 100)
+                .Select(selector)
+                .ToArray();
+            var func = new MultFunction();
+            var structEnum = StructEnumerable
+                .Range(-50, 100)
+                .Select(ref func, x=>x, x=> x)
+                .ToEnumerable()
+                .ToArray();
+            Assert.Equal(sys, structEnum);
+        }
+
+        protected override SelectCollection<int, double, RangeEnumerable, RangeEnumerator, MultFunction> Build(int size)
+        {
+            var func = new MultFunction();
+            var selectEnumerable = 
+                StructEnumerable.Range(-1, size).Select(ref func, x=>x, x => x);
+            return selectEnumerable;
+        }
+    }
+}

src/StructLinq.Tests/SelectCollectionTests.cs

@@ -2,36 +2,38 @@
 using System.Linq;
 using StructLinq.Range;
 using StructLinq.Select;
+using StructLinq.Where;
 using Xunit;
 
 namespace StructLinq.Tests
 {
     public class SelectFuncTests : AbstractEnumerableTests<double,
-        SelectEnumerable<int, double, RangeEnumerable, RangeEnumerator>,
-        SelectEnumerator<int, double, RangeEnumerator>>
+        SelectEnumerable<int, double, WhereEnumerable<int, IStructEnumerable<int, RangeEnumerator>, RangeEnumerator>, WhereEnumerator<int, RangeEnumerator>>,
+        SelectEnumerator<int, double, WhereEnumerator<int, RangeEnumerator>>>
     {
         [Fact]
         public void DelegateTest()
         {
             Func<int, double> selector = x => x * 2.0;
             var sys = Enumerable
-                      .Range(-50, 100)
-                      .Select(selector)
-                      .ToArray();
+                .Range(-50, 100)
+                .Select(selector)
+                .ToArray();
             var structEnum = StructEnumerable
-                             .Range(-50, 100)
-                             .Select(selector)
-                             .ToEnumerable()
-                             .ToArray();
+                .Range(-50, 100)
+                .Select(selector)
+                .ToEnumerable()
+                .ToArray();
             Assert.Equal(sys, structEnum);
         }
 
-        protected override SelectEnumerable<int, double, RangeEnumerable, RangeEnumerator> Build(int size)
+        protected override SelectEnumerable<int, double, WhereEnumerable<int, IStructEnumerable<int, RangeEnumerator>, RangeEnumerator>, WhereEnumerator<int, RangeEnumerator>> Build(int size)
         {
             var selectEnumerable = 
-                StructEnumerable.Range(-1, size).Select(x=> x * 2.0, x=> x);
+                StructEnumerable.Range(-1, size).Where(x=> true).Select(x=> x * 2.0, x=> x);
             return selectEnumerable;
         }
 
     }
+
 }

src/StructLinq.Tests/SelectFuncTests.cs

@@ -2,41 +2,43 @@
 using System.Linq;
 using StructLinq.Range;
 using StructLinq.Select;
+using StructLinq.Where;
 using Xunit;
 
 namespace StructLinq.Tests
 {
     public class SelectTests : AbstractEnumerableTests<double,
-        SelectEnumerable<int, double, RangeEnumerable, RangeEnumerator, MultFunction>,
-        SelectEnumerator<int, double, RangeEnumerator, MultFunction>>
+        SelectEnumerable<int, double, WhereEnumerable<int, IStructEnumerable<int, RangeEnumerator>, RangeEnumerator>, WhereEnumerator<int, RangeEnumerator>, MultFunction>,
+        SelectEnumerator<int, double, WhereEnumerator<int, RangeEnumerator>, MultFunction>>
     {
         [Fact]
         public void DelegateTest()
         {
             Func<int, double> selector = x => x * 2.0;
             var sys = Enumerable
-                      .Range(-50, 100)
-                      .Select(selector)
-                      .ToArray();
+                .Range(-50, 100)
+                .Select(selector)
+                .ToArray();
             var func = new MultFunction();
             var structEnum = StructEnumerable
-                             .Range(-50, 100)
-                             .Select(ref func, x=>x, x=> x)
-                             .ToEnumerable()
-                             .ToArray();
+                .Range(-50, 100)
+                .Select(ref func, x=>x, x=> x)
+                .ToEnumerable()
+                .ToArray();
             Assert.Equal(sys, structEnum);
         }
 
-        protected override SelectEnumerable<int, double, RangeEnumerable, RangeEnumerator, MultFunction> Build(int size)
+        protected override SelectEnumerable<int, double, WhereEnumerable<int, IStructEnumerable<int, RangeEnumerator>, RangeEnumerator>, WhereEnumerator<int, RangeEnumerator>, MultFunction> Build(int size)
         {
             var func = new MultFunction();
-            SelectEnumerable<int, double, RangeEnumerable, RangeEnumerator, MultFunction> selectEnumerable = 
-                StructEnumerable.Range(-1, size).Select(ref func, x=>x, x => x);
+            var selectEnumerable = 
+                StructEnumerable.Range(-1, size).Where(x=> true).Select(ref func, x=>x, x => x);
             return selectEnumerable;
         }
 
     }
-    
+
+
     public struct MultFunction : IFunction<int, double>
     {
         public double Eval(int element)

src/StructLinq.Tests/SelectTests.cs

@@ -0,0 +1,53 @@
+using System.Runtime.CompilerServices;
+
+namespace StructLinq.Select
+{
+    public struct RefSelectCollection<TIn, TOut, TEnumerable, TEnumerator, TFunction> : IStructCollection<TOut, RefSelectEnumerator<TIn, TOut, TEnumerator, TFunction>>
+        where TFunction : struct, IInFunction<TIn, TOut>
+        where TEnumerator : struct, IRefStructEnumerator<TIn>
+        where TEnumerable : IRefStructCollection<TIn, TEnumerator>
+    {
+        #region private fields
+        private TFunction function;
+        private TEnumerable inner;
+        #endregion
+
+        public RefSelectCollection(ref TFunction function, ref TEnumerable inner)
+        {
+            this.function = function;
+            this.inner = inner;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public RefSelectEnumerator<TIn, TOut, TEnumerator, TFunction> GetEnumerator()
+        {
+            var typedEnumerator = inner.GetEnumerator();
+            return new RefSelectEnumerator<TIn, TOut, TEnumerator, TFunction>(ref function, ref typedEnumerator);
+        }
+
+        public int Count
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => inner.Count;
+        }
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Slice(uint start, uint? length)
+        {
+            inner.Slice(start, length);
+        }
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public object Clone()
+        {
+            return this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TOut Get(int i)
+        {
+            return function.Eval(inner.Get(i));
+        }
+
+    }
+}

src/StructLinq/Select/RefSelectCollection.cs

@@ -24,11 +24,5 @@ public RefSelectEnumerator<TIn, TOut, TEnumerator, TFunction> GetEnumerator()
             var typedEnumerator = inner.GetEnumerator();
             return new RefSelectEnumerator<TIn, TOut, TEnumerator, TFunction>(ref function, ref typedEnumerator);
         }
-
-        internal TEnumerable Inner
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => inner;
-        }
     }
 }

src/StructLinq/Select/RefSelectEnumerable.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Runtime.CompilerServices;
+using StructLinq.Select;
+
+// ReSharper disable once CheckNamespace
+namespace StructLinq
+{
+    public static partial class StructEnumerable
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static RefSelectCollection<TIn, TOut, TEnumerable, TEnumerator, TFunction> Select<TIn, TOut, TEnumerable, TEnumerator, TFunction>(
+            this TEnumerable enumerable,
+            ref TFunction function, 
+            Func<TEnumerable, IRefStructCollection<TIn, TEnumerator>> _,
+            Func<TFunction, IInFunction<TIn, TOut>> __)
+            where TEnumerator : struct, IRefStructEnumerator<TIn>
+            where TFunction : struct, IInFunction<TIn, TOut>
+            where TEnumerable : struct, IRefStructCollection<TIn, TEnumerator>
+        {
+            return new RefSelectCollection<TIn, TOut, TEnumerable, TEnumerator, TFunction>(ref function, ref enumerable);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static RefSelectCollection<TIn, TOut, TEnumerable, TEnumerator, StructInFunction<TIn, TOut>> Select<TIn, TOut, TEnumerable, TEnumerator>(
+            this TEnumerable enumerable, 
+            InFunc<TIn, TOut> function, 
+            Func<TEnumerable, IRefStructCollection<TIn, TEnumerator>> _)
+            where TEnumerator : struct, IRefStructEnumerator<TIn>
+            where TEnumerable : struct, IRefStructCollection<TIn, TEnumerator>
+        {
+            var fct = function.ToStruct();
+            return new RefSelectCollection<TIn, TOut, TEnumerable, TEnumerator, StructInFunction<TIn, TOut>>(ref fct, ref enumerable);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static RefSelectCollection<TIn, TOut, IRefStructCollection<TIn, TEnumerator>, TEnumerator, StructInFunction<TIn, TOut>> Select<TIn, TOut, TEnumerator>(
+            this IRefStructCollection<TIn, TEnumerator> enumerable, 
+            InFunc<TIn, TOut> function)
+            where TEnumerator : struct, IRefStructEnumerator<TIn>
+        {
+            var fct = function.ToStruct();
+            return new RefSelectCollection<TIn, TOut, IRefStructCollection<TIn, TEnumerator>, TEnumerator, StructInFunction<TIn, TOut>>(ref fct, ref enumerable);
+        }
+    }
+}