/// <summary> /// Returns a sequence consisting of the head elements and the given tail element. /// </summary> /// <typeparam name="T">Type of sequence</typeparam> /// <param name="head">All elements of the head. Must not be null.</param> /// <param name="tail">Tail element of the new sequence.</param> /// <returns>A sequence consisting of the head elements and the given tail element.</returns> /// <remarks>This operator uses deferred execution and streams its results.</remarks> public static IEnumerable <T> Concat <T>(this IEnumerable <T> head, T tail) { if (head == null) { throw new ArgumentNullException(nameof(head)); } return(LinqEnumerable.Concat(head, LinqEnumerable.Repeat(tail, 1))); }
/// <summary> /// Prepends a single value to a sequence. /// </summary> /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam> /// <param name="source">The sequence to prepend to.</param> /// <param name="value">The value to prepend.</param> /// <returns> /// Returns a sequence where a value is prepended to it. /// </returns> /// <remarks> /// This operator uses deferred execution and streams its results. /// </remarks> /// <code> /// int[] numbers = { 1, 2, 3 }; /// IEnumerable<int> result = numbers.Prepend(0); /// </code> /// The /// <c>result</c> /// variable, when iterated over, will yield /// 0, 1, 2 and 3, in turn. public static IEnumerable <TSource> Prepend <TSource>(this IEnumerable <TSource> source, TSource value) { if (source == null) { throw new ArgumentNullException("source"); } return(LinqEnumerable.Concat(LinqEnumerable.Repeat(value, 1), source)); }
public void IndexOfTest() { Assert.AreEqual(-1, Enumerable.Range(0, 5).IndexOf(-1)); Assert.AreEqual(-1, Enumerable.Range(0, 5).IndexOf(6)); Assert.AreEqual(0, Enumerable.Range(0, 5).IndexOf(0)); Assert.AreEqual(1, Enumerable.Range(0, 5).IndexOf(1)); Assert.AreEqual(-1, Enumerable.Repeat("a", 5).IndexOf("A")); Assert.AreEqual(0, Enumerable.Repeat("a", 5).IndexOf("A", comparer: StringComparer.OrdinalIgnoreCase)); }
private void NullCheckValueChanged(object sender, ValueChangedEventArgs e) { if (nullCheck.Value) { OnAddItems(SL.Repeat(default(T), nulls)); } else { OnRemoveItems(SL.Repeat(default(T), nulls)); } }
public void LastIndexOfTest() { Assert.AreEqual(-1, Enumerable.Range(0, 5).LastIndexOf(-1)); Assert.AreEqual(-1, Enumerable.Range(0, 5).LastIndexOf(6)); Assert.AreEqual(0, Enumerable.Range(0, 5).LastIndexOf(0)); Assert.AreEqual(1, Enumerable.Range(0, 5).LastIndexOf(1)); Assert.AreEqual(4, Enumerable.Repeat(0, 5).LastIndexOf(0)); Assert.AreEqual(6, Enumerable.Repeat(0, 5).Concat(Enumerable.Range(0, 5)).LastIndexOf(1)); Assert.AreEqual(-1, Enumerable.Repeat("a", 5).LastIndexOf("A")); Assert.AreEqual(4, Enumerable.Repeat("a", 5).LastIndexOf("A", StringComparer.OrdinalIgnoreCase)); }
private void LambdaChanged(object sender, ValueChangedEventArgs e) { var lambdaResult = sender as TaggedObservableValue <bool, ItemMultiplicity>; if (lambdaResult.Value) { OnAddItems(SL.Repeat(lambdaResult.Tag.Item, lambdaResult.Tag.Multiplicity)); } else { OnRemoveItems(SL.Repeat(lambdaResult.Tag.Item, lambdaResult.Tag.Multiplicity)); } }
private static IEnumerable <SyntaxTrivia> GetUseTabsModeIndentTrivias(int indentSize, int tabSize) { foreach (SyntaxTrivia indentTabTrivia in Enumerable.Repeat(SyntaxFactory.Tab, indentSize / tabSize)) { yield return(indentTabTrivia); } int remainingSpaceTrivia = indentSize % tabSize; if (remainingSpaceTrivia != 0) { yield return(SyntaxFactory.Whitespace(new string(' ', remainingSpaceTrivia))); } }
public static string GenerateReceiptId() { var currentUtcTime = DateTime.Now; return("SAI" + currentUtcTime.ToString("yyyy") + string.Concat(Enumerable.Repeat('0', 3 - currentUtcTime.DayOfYear.ToString().Length)) + currentUtcTime.DayOfYear + string.Concat(Enumerable.Repeat('0', 2 - currentUtcTime.Hour.ToString().Length)) + currentUtcTime.Hour + string.Concat(Enumerable.Repeat('0', 2 - currentUtcTime.Minute.ToString().Length)) + currentUtcTime.Minute + string.Concat(Enumerable.Repeat('0', 2 - currentUtcTime.Second.ToString().Length)) + currentUtcTime.Second); }
public void RemoveAllTest() { EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(-1)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(0)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(1)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(2)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAll(3)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAll(4)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(5)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(6)); EnumerableAssert.AreSequentialEqual(new int[] { }, Enumerable.Repeat(0, 5).RemoveAll(0)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 0, 0, 0, 0 }, Enumerable.Repeat(0, 5).RemoveAll(1)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 0, 1, 2, 3 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(4)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(0)); }
public void RepeatTest() { EnumerableAssert.AreSequentialEqual( Enumerable.Repeat(1, 5), IteratorPattern.Repeat(1, 5)); EnumerableAssert.AreSequentialEqual( Enumerable.Repeat(1, 0), IteratorPattern.Repeat(1, 0)); EnumerableAssert.AreSequentialEqual( Enumerable.Repeat(1, 1), IteratorPattern.Repeat(1, 1)); object value = new object(); EnumerableAssert.AreSequentialEqual( Enumerable.Repeat(value, 10), IteratorPattern.Repeat(value, 10)); }
/// <summary> /// Returns a sequence consisting of the head elements and the given tail element. /// </summary> /// <typeparam name="T">Type of sequence</typeparam> /// <param name="head">All elements of the head. Must not be null.</param> /// <param name="tail">Tail element of the new sequence.</param> /// <returns>A sequence consisting of the head elements and the given tail element.</returns> /// <remarks>This operator uses deferred execution and streams its results.</remarks> public static IEnumerable <T> Concat <T> (this IEnumerable <T> head, T tail) { head.ThrowIfNull("head"); return(LinqEnumerable.Concat(head, LinqEnumerable.Repeat(tail, 1))); }
public void RemoveAllTest() { try { int[] removeAll = Enumerable.Range(0, 5).RemoveAll(-1).ToArray(); Assert.Fail(string.Join(", ", removeAll.Select(int32 => int32.ToString()))); } catch (ArgumentOutOfRangeException exception) { Assert.AreEqual("remove", exception.ParamName); } EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(0)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(1)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(2)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAll(3)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAll(4)); try { int[] removeAll = Enumerable.Range(0, 5).RemoveAll(5).ToArray(); Assert.Fail(string.Join(", ", removeAll.Select(int32 => int32.ToString()))); } catch (ArgumentOutOfRangeException exception) { Assert.AreEqual("remove", exception.ParamName); } try { int[] removeAll = Enumerable.Range(0, 5).RemoveAll(6).ToArray(); Assert.Fail(string.Join(", ", removeAll.Select(int32 => int32.ToString()))); } catch (ArgumentOutOfRangeException exception) { Assert.AreEqual("remove", exception.ParamName); } EnumerableAssert.AreSequentialEqual(Enumerable.Empty <int>(), Enumerable.Repeat(0, 5).RemoveAll(0)); try { int[] removeAll = Enumerable.Repeat(0, 5).RemoveAll(1).ToArray(); Assert.Fail(string.Join(", ", removeAll.Select(int32 => int32.ToString()))); } catch (ArgumentOutOfRangeException exception) { Assert.AreEqual("remove", exception.ParamName); } EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 0, 1, 2, 3 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(4)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(0)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(-1, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(0, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(1, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(2, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAll(3, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAll(4, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(5, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(6, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(Enumerable.Empty <int>(), Enumerable.Repeat(0, 5).RemoveAll(0, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(Enumerable.Repeat(0, 5), Enumerable.Repeat(0, 5).RemoveAll(1, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 0, 1, 2, 3 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(4, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(0, null, ListQueryMode.Normalize)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(-1, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(0, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(1, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(2, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 4 }, Enumerable.Range(0, 5).RemoveAll(3, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3 }, Enumerable.Range(0, 5).RemoveAll(4, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).RemoveAll(5, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Remove(6, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(Enumerable.Empty <int>(), Enumerable.Repeat(0, 5).RemoveAll(0, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(Enumerable.Repeat(0, 5), Enumerable.Repeat(0, 5).RemoveAll(1, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 0, 1, 2, 3, 0, 1, 2, 3 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(4, null, ListQueryMode.Ignore)); EnumerableAssert.AreSequentialEqual(new int[] { 1, 2, 3, 4, 1, 2, 3, 4 }, Enumerable.Range(0, 5).Concat(Enumerable.Range(0, 5)).RemoveAll(0, null, ListQueryMode.Ignore)); }
public void NegativeCountIsInvalid() { Assert.Throws <ArgumentOutOfRangeException>(() => Linq.Repeat("string", -8)); }
public void NullValuesAllowed() { Linq.Repeat <string>(null, 3).Should().BeEquivalentTo(new string[] { null, null, null }); }
public void WhenCount0ReturnsEmptyCollection() { Linq.Repeat("string", 0).Should().BeEmpty(); }
public void RepeatsString() { var repeatSequence = Linq.Repeat("string", 3); repeatSequence.Should().BeEquivalentTo("string", "string", "string"); }
public override INotificationResult Notify(IList <INotificationResult> sources) { var added = new List <T>(); var removed = new List <T>(); foreach (var change in sources) { if (change.Source == source) { var sourceChange = (CollectionChangedNotificationResult <T>)change; if (sourceChange.IsReset) { foreach (var item in lambdaInstances.Values) { item.Successors.Unset(this); } lambdaInstances.Clear(); foreach (var item in source) { AttachItem(item); } OnCleared(); return(new CollectionChangedNotificationResult <T>(this)); } else { NotifySource(sourceChange, added, removed); } } else if (nullCheck != null && change.Source == nullCheck) { if (nullCheck.Value) { added.AddRange(SL.Repeat(default(T), nulls)); } else { removed.AddRange(SL.Repeat(default(T), nulls)); } } else { var lambdaResult = (TaggedObservableValue <bool, ItemMultiplicity>)change.Source; if (lambdaResult.Value) { added.AddRange(SL.Repeat(lambdaResult.Tag.Item, lambdaResult.Tag.Multiplicity)); } else { removed.AddRange(SL.Repeat(lambdaResult.Tag.Item, lambdaResult.Tag.Multiplicity)); } } } if (added.Count == 0 && removed.Count == 0) { return(UnchangedNotificationResult.Instance); } OnRemoveItems(removed); OnAddItems(added); return(new CollectionChangedNotificationResult <T>(this, added, removed)); }
/// <summary> /// Prepends a single value to a sequence. /// </summary> /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam> /// <param name="source">The sequence to prepend to.</param> /// <param name="value">The value to prepend.</param> /// <returns> /// Returns a sequence where a value is prepended to it. /// </returns> /// <remarks> /// This operator uses deferred execution and streams its results. /// </remarks> /// <code> /// int[] numbers = { 1, 2, 3 }; /// IEnumerable<int> result = numbers.Prepend(0); /// </code> /// The <c>result</c> variable, when iterated over, will yield /// 0, 1, 2 and 3, in turn. public static IEnumerable <TSource> Prepend <TSource> (this IEnumerable <TSource> source, TSource value) { source.ThrowIfNull("source"); return(LinqEnumerable.Concat(LinqEnumerable.Repeat(value, 1), source)); }