public void Constructor() { var builder = new LargeArrayBuilder <T>(initialize: true); Assert.Equal(0, builder.Count); Assert.Same(Array.Empty <T>(), builder.ToArray()); }
public static T[] MyToArray <T>(this IEnumerable <T> enumerable) { var builder = new LargeArrayBuilder <T>(true); builder.AddRange(enumerable); return(builder.ToArray()); }
public void ToArray_ArrayPool_Must_Succeed(int count) { // Arrange var pool = ArrayPool <int> .Shared; var expected = Enumerable .Range(0, count) .ToArray(); using var builder = new LargeArrayBuilder <int>(ArrayPool <int> .Shared); for (var index = 0; index < count; index++) { builder.Add(expected[index]); } // Act var result = builder.ToArray(pool); try { // Assert _ = result.Must() .BeEqualTo(expected); } finally { pool.Return(result.Array); } }
public TResult[] ToArray() { var builder = new LargeArrayBuilder <TResult>(initialize: true); foreach (TSource item in _source) { builder.Add(_selector(item)); } return(builder.ToArray()); }
public TResult[] ToArray() { var builder = new LargeArrayBuilder <TResult>(initialize: true); foreach (TSource element in _source) { builder.AddRange(_selector(element)); } return(builder.ToArray()); }
private TResult[] LazyToArray() { Debug.Assert(_source.GetCount(onlyIfCheap: true) == -1); var builder = new LargeArrayBuilder <TResult>(initialize: true); foreach (TSource input in _source) { builder.Add(_selector(input)); } return(builder.ToArray()); }
public void AddRange(IEnumerable <T> seed) { var builder = new LargeArrayBuilder <T>(initialize: true); // Call AddRange multiple times and verify contents w/ each iteration. for (int i = 1; i <= 10; i++) { builder.AddRange(seed); IEnumerable <T> expected = Enumerable.Repeat(seed, i).SelectMany(s => s); Assert.Equal(expected, builder.ToArray()); } }
public void MaxCapacity(IEnumerable <T> seed, int maxCapacity) { var builder = new LargeArrayBuilder <T>(maxCapacity); for (int i = 0; i < maxCapacity; i++) { builder.Add(seed.ElementAt(i)); int count = i + 1; Assert.Equal(count, builder.Count); Assert.Equal(seed.Take(count), builder.ToArray()); } }
public TSource[] ToArray() { var builder = new LargeArrayBuilder <TSource>(_source.Length); foreach (TSource item in _source) { if (_predicate(item)) { builder.Add(item); } } return(builder.ToArray()); }
public TResult[] ToArray() { var builder = new LargeArrayBuilder <TResult>(_source.Count); for (int i = 0; i < _source.Count; i++) { TSource item = _source[i]; if (_predicate(item)) { builder.Add(_selector(item)); } } return(builder.ToArray()); }
public virtual TSource[] ToArray() { var builder = new LargeArrayBuilder <TSource>(initialize: true); for (int i = 0; ; i++) { IEnumerable <TSource> source = GetEnumerable(i); if (source == null) { break; } builder.AddRange(source); } return(builder.ToArray()); }
private TSource[] LazyToArray() { Debug.Assert(GetCount(onlyIfCheap: true) == -1); var builder = new LargeArrayBuilder <TSource>(initialize: true); if (!_appending) { builder.SlowAdd(_item); } builder.AddRange(_source); if (_appending) { builder.SlowAdd(_item); } return(builder.ToArray()); }
public void ToArray_Must_Succeed(int count) { // Arrange var expected = Enumerable .Range(0, count) .ToArray(); using var builder = new LargeArrayBuilder <int>(ArrayPool <int> .Shared); for (var index = 0; index < count; index++) { builder.Add(expected[index]); } // Act var result = builder.ToArray(); // Assert _ = result.Must() .BeArrayOf <int>() .BeEqualTo(expected); }
public void AddCountAndToArray(IEnumerable <T> seed) { var builder1 = new LargeArrayBuilder <T>(initialize: true); var builder2 = new LargeArrayBuilder <T>(initialize: true); int count = 0; foreach (T item in seed) { count++; builder1.Add(item); builder2.SlowAdd(item); // Verify SlowAdd has exactly the same effect as Add. Assert.Equal(count, builder1.Count); Assert.Equal(count, builder2.Count); Assert.Equal(seed.Take(count), builder1.ToArray()); Assert.Equal(seed.Take(count), builder2.ToArray()); } }
private TSource[] LazyToArray() { Debug.Assert(GetCount(onlyIfCheap: true) == -1); var builder = new LargeArrayBuilder <TSource>(initialize: true); for (SingleLinkedNode <TSource> node = _prepended; node != null; node = node.Linked) { builder.Add(node.Item); } builder.AddRange(_source); if (_appended != null) { foreach (TSource item in _appended.ToArray()) { builder.Add(item); } } return(builder.ToArray()); }
public TSource[] ToArray() { using (IEnumerator <TSource> en = _source.GetEnumerator()) { if (SkipBeforeFirst(en) && en.MoveNext()) { int remaining = Limit - 1; // Max number of items left, not counting the current element. int comparand = HasLimit ? 0 : int.MinValue; // If we don't have an upper bound, have the comparison always return true. int maxCapacity = HasLimit ? Limit : int.MaxValue; var builder = new LargeArrayBuilder <TSource>(maxCapacity); do { remaining--; builder.Add(en.Current); }while (remaining >= comparand && en.MoveNext()); return(builder.ToArray()); } } return(Array.Empty <TSource>()); }