public void DeserializeStackInterface() { string json = @"[ ""One"", ""II"", ""3"" ]"; IImmutableStack <string> data = JsonSerializer.Deserialize <IImmutableStack <string> >(json); Assert.False(data.IsEmpty); Assert.Equal("3", data.Peek()); data = data.Pop(); Assert.Equal("II", data.Peek()); data = data.Pop(); Assert.Equal("One", data.Peek()); }
public static IImmutableStack <T> Pop <T>(this IImmutableStack <T> stack, out T value) { Requires.NotNull(stack, "stack"); Contract.Ensures(Contract.Result <IImmutableStack <T> >() != null); value = stack.Peek(); return(stack.Pop()); }
public GameState Undo() { var moves = _moves.Pop(); return(moves.IsEmpty ? this : new GameState(moves, CursorPosition)); }
public IEnumerator <T> GetEnumerator() { IImmutableStack <T> stack = this; do { yield return(stack.Peek()); stack = stack.Pop(); }while (stack != Empty); }
public static IImmutableStack <T> Pop <T>( this IImmutableStack <T> stack, out T value) { if (stack == null) { throw new ArgumentNullException(nameof(stack)); } value = stack.Peek(); return(stack.Pop()); }
public static IImmutableStack <T> Reverse <T>(this IImmutableStack <T> stack) { var reverse = Empty <T>(); while (!stack.IsEmpty) { reverse = reverse.Push(stack.Peek()); stack = stack.Pop(); } return(reverse); }
public static Tuple <IImmutableStack <T>, Option <T> > pop <T>(IImmutableStack <T> stack) { try { T value; var newStack = stack.Pop(out value); return(tuple(newStack, Some(value))); } catch (InvalidOperationException) { return(tuple(stack, Option <T> .None)); } }
bool IEnumerator.MoveNext() { if (current == null) { current = this.start; } else if (!current.IsEmpty) { current = current.Pop(); } return(!current.IsEmpty); }
public IImmutableQueue <T> Dequeue() { IImmutableStack <T> f = forwards.Pop(); if (!f.IsEmpty) { return(new ImmutableQueue <T>(f, backwards)); } if (backwards.IsEmpty) { return(Empty); } return(new ImmutableQueue <T>((IImmutableStack <T>)backwards.Reverse(), ImmutableStack <T> .Empty)); }
bool IEnumerator.MoveNext() { if (frontStack == null) { frontStack = start.frontStack; backStack = start.backStack; } else if (!frontStack.IsEmpty) { frontStack = frontStack.Pop(); } else if (!backStack.IsEmpty) { backStack = backStack.Pop(); } return(!(frontStack.IsEmpty || backStack.IsEmpty)); }
public void PopOutValue() { var stack = ImmutableStack <int> .Empty.Push(5).Push(6); int top; stack = stack.Pop(out top); Assert.Equal(6, top); var empty = stack.Pop(out top); Assert.Equal(5, top); Assert.True(empty.IsEmpty); // Try again with the interface to verify extension method behavior. IImmutableStack <int> stackInterface = stack; Assert.Same(empty, stackInterface.Pop(out top)); Assert.Equal(5, top); }
static IImmutableStack <T> GetPrevElementInHierarchyCore <T>(IImmutableStack <T> rootStack, Func <T, IList <T> > getChildren, Func <IList <T>, T, int> indedOf) where T : class { var currentElement = rootStack.Peek(); Func <T, IEnumerable <T> > getChildrenPath = element => LinqExtensions.Unfold(element, x => getChildren(x).LastOrDefault(), x => x == null); var parents = rootStack.Pop(); var parent = parents.FirstOrDefault(); if (parent == null) { return(ImmutableStack.Empty <T>().PushMultiple(getChildrenPath(currentElement))); } var neighbors = getChildren(parent); var index = indedOf(neighbors, currentElement); if (index > 0) { return(parents.PushMultiple(getChildrenPath(neighbors[index - 1]))); } return(parents); }
private static ImmutableStack <T> Reverse(IImmutableStack <T> stack) { ImmutableStack <T> immutableStack1 = ImmutableStack <T> .Empty; for (IImmutableStack <T> immutableStack2 = stack; !immutableStack2.IsEmpty; immutableStack2 = immutableStack2.Pop()) { immutableStack1 = immutableStack1.Push(immutableStack2.Peek()); } return(immutableStack1); }
public static void Deconstruct <T>(this IImmutableStack <T> src, out T head, out IImmutableStack <T> tail) { head = src.Peek(); tail = src.Pop(); }