Skip to content

Commit

Permalink
Remove unnecessary code
Browse files Browse the repository at this point in the history
  • Loading branch information
@aalmada
aalmada committed Feb 2, 2021
1 parent fad5cfa commit 5860d8d
Show file tree
Hide file tree
Showing 8 changed files with 14 additions and 314 deletions.
65 changes: 0 additions & 65 deletions NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Memory.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,71 +9,6 @@ public static partial class ArrayExtensions
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static IMemoryOwner<TSource> ToArray<TSource>(this Memory<TSource> source, MemoryPool<TSource> pool)
=> source.Span.ToArray(pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArray<TSource, TPredicate>(this Memory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, bool>
=> source.Span.ToArray(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArray<TSource, TPredicate>(this Memory<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, bool>
=> source.Span.ToArray(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArrayAt<TSource, TPredicate>(this Memory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, int, bool>
=> source.Span.ToArrayAt(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArrayAt<TSource, TPredicate>(this Memory<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, int, bool>
=> source.Span.ToArrayAt(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TSelector>(this Memory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TSelector>(this Memory<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayAt<TSource, TResult, TSelector>(this Memory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, int, TResult>
=> source.Span.ToArrayAt<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayAt<TSource, TResult, TSelector>(this Memory<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, int, TResult>
=> source.Span.ToArrayAt(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TPredicate, TSelector>(this Memory<TSource> source, TPredicate predicate, TSelector selector)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TPredicate, TSelector>(this Memory<TSource> source, TPredicate predicate, TSelector selector, MemoryPool<TResult> pool)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray(predicate, selector, pool);
}
}

65 changes: 0 additions & 65 deletions NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlyMemory.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,71 +9,6 @@ public static partial class ArrayExtensions
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static IMemoryOwner<TSource> ToArray<TSource>(this ReadOnlyMemory<TSource> source, MemoryPool<TSource> pool)
=> source.Span.ToArray(pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArray<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, bool>
=> source.Span.ToArray(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArray<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, bool>
=> source.Span.ToArray(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArrayAt<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, int, bool>
=> source.Span.ToArrayAt(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArrayAt<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, int, bool>
=> source.Span.ToArrayAt(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayAt<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, int, TResult>
=> source.Span.ToArrayAt<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayAt<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, int, TResult>
=> source.Span.ToArrayAt(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TPredicate, TSelector>(this ReadOnlyMemory<TSource> source, TPredicate predicate, TSelector selector)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TPredicate, TSelector>(this ReadOnlyMemory<TSource> source, TPredicate predicate, TSelector selector, MemoryPool<TResult> pool)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> source.Span.ToArray(predicate, selector, pool);
}
}

116 changes: 0 additions & 116 deletions NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Span.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,122 +9,6 @@ public static partial class ArrayExtensions
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static IMemoryOwner<TSource> ToArray<TSource>(this Span<TSource> source, MemoryPool<TSource> pool)
=> ((ReadOnlySpan<TSource>)source).ToArray(pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArray<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, bool>
=> ((ReadOnlySpan<TSource>)source).ToArray(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArrayRef<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunctionIn<TSource, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArray<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, bool>
=> ((ReadOnlySpan<TSource>)source).ToArray(predicate, pool);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArrayRef<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunctionIn<TSource, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArrayAt<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, int, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayAt<TSource, TPredicate>(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TSource[] ToArrayAtRef<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunctionIn<TSource, int, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayAtRef<TSource, TPredicate>(predicate);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArrayAt<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunction<TSource, int, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayAt(predicate, pool);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TSource> ToArrayAtRef<TSource, TPredicate>(this Span<TSource> source, TPredicate predicate, MemoryPool<TSource> pool)
where TPredicate : struct, IFunctionIn<TSource, int, bool>
=> ((ReadOnlySpan<TSource>)source).ToArrayAtRef(predicate, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArray<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayRef<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector)
where TSelector : struct, IFunctionIn<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArray(selector, pool);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayRef<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunctionIn<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayAt<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, int, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayAt<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayAtRef<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector)
where TSelector : struct, IFunctionIn<TSource, int, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayAtRef<TSource, TResult, TSelector>(selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayAt<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunction<TSource, int, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayAt(selector, pool);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayAtRef<TSource, TResult, TSelector>(this Span<TSource> source, TSelector selector, MemoryPool<TResult> pool)
where TSelector : struct, IFunctionIn<TSource, int, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayAtRef(selector, pool);

//////////////////////////////////////////////////////////////////////////////////////////////////

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArray<TSource, TResult, TPredicate, TSelector>(this Span<TSource> source, TPredicate predicate, TSelector selector)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static TResult[] ToArrayRef<TSource, TResult, TPredicate, TSelector>(this Span<TSource> source, TPredicate predicate, TSelector selector)
where TPredicate : struct, IFunctionIn<TSource, bool>
where TSelector : struct, IFunctionIn<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef<TSource, TResult, TPredicate, TSelector>(predicate, selector);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArray<TSource, TResult, TPredicate, TSelector>(this Span<TSource> source, TPredicate predicate, TSelector selector, MemoryPool<TResult> pool)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArray(predicate, selector, pool);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static IMemoryOwner<TResult> ToArrayRef<TSource, TResult, TPredicate, TSelector>(this Span<TSource> source, TPredicate predicate, TSelector selector, MemoryPool<TResult> pool)
where TPredicate : struct, IFunctionIn<TSource, bool>
where TSelector : struct, IFunctionIn<TSource, TResult>
=> ((ReadOnlySpan<TSource>)source).ToArrayRef(predicate, selector, pool);
}
}

55 changes: 1 addition & 54 deletions NetFabric.Hyperlinq/Conversion/ToList/ToList.ReadOnlyMemory.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,59 +12,6 @@ public static partial class ArrayExtensions

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static List<TSource> ToList<TSource>(this ReadOnlyMemory<TSource> source)
=> source.Length switch
{
0 => new List<TSource>(),
_ => source.ToArray().AsList()
};

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TSource> ToList<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, bool>
=> source.Length switch
{
0 => new List<TSource>(),
_ => source.ToArray(predicate).AsList()
};

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TSource> ToListAt<TSource, TPredicate>(this ReadOnlyMemory<TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction<TSource, int, bool>
=> source.Length switch
{
0 => new List<TSource>(),
_ => source.ToArrayAt<TSource, TPredicate>(predicate).AsList()
};


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TResult> ToList<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, TResult>
=> source.Length switch
{
0 => new List<TResult>(),
_ => source.ToArray<TSource, TResult, TSelector>(selector).AsList()
};


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TResult> ToListAt<TSource, TResult, TSelector>(this ReadOnlyMemory<TSource> source, TSelector selector)
where TSelector : struct, IFunction<TSource, int, TResult>
=> source.Length switch
{
0 => new List<TResult>(),
_ => source.ToArrayAt<TSource, TResult, TSelector>(selector).AsList()
};


[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TResult> ToList<TSource, TResult, TPredicate, TSelector>(this ReadOnlyMemory<TSource> source, TPredicate predicate, TSelector selector)
where TPredicate : struct, IFunction<TSource, bool>
where TSelector : struct, IFunction<TSource, TResult>
=> source.Length switch
{
0 => new List<TResult>(),
_ => source.ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector).AsList()
};
=> source.Span.ToList();
}
}
11 changes: 5 additions & 6 deletions NetFabric.Hyperlinq/Conversion/ToList/ToList.ReadOnlySpan.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,12 +11,11 @@ public static partial class ArrayExtensions

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static List<TSource> ToList<TSource>(this ReadOnlySpan<TSource> source)
{
var list = new List<TSource>(source.Length);
for (var index = 0; index < source.Length; index++)
list.Add(source[index]);
return list;
}
=> source.Length switch
{
0 => new List<TSource>(),
_ => source.ToArray().AsList()
};

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static List<TSource> ToList<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
Expand Down
Loading

0 comments on commit 5860d8d

Please sign in to comment.