public int Sum(IImmutableStack <int> stack) => map(pop(stack), (newstack, option) => match(option, Some: value => value + Sum(newstack), None: () => 0 ) );
public ResolverTask( IExecutionContext executionContext, ObjectType objectType, FieldSelection fieldSelection, Path path, IImmutableStack <object> source, OrderedDictionary result) { _executionContext = executionContext; Source = source; ObjectType = objectType; FieldSelection = fieldSelection; FieldType = fieldSelection.Field.Type; Path = path; Result = result; ResolverContext = new ResolverContext( executionContext, this, executionContext.RequestAborted); Options = executionContext.Options; ExecuteMiddleware = executionContext.GetMiddleware( objectType, fieldSelection.Selection); HasMiddleware = ExecuteMiddleware != null; }
private ResolverTask( ResolverTask parent, FieldSelection fieldSelection, Path path, IImmutableStack <object> source, IDictionary <string, object> result, Action propagateNonNullViolation) { _parent = parent; _executionContext = parent._executionContext; Source = source; ObjectType = fieldSelection.Field.DeclaringType; FieldSelection = fieldSelection; FieldType = fieldSelection.Field.Type; Path = path; _result = result; ScopedContextData = parent.ScopedContextData; _propagateNonNullViolation = propagateNonNullViolation; ResolverContext = new ResolverContext( parent._executionContext, this, parent._executionContext.RequestAborted); FieldDelegate = parent._executionContext.FieldHelper .CreateMiddleware(fieldSelection); }
private void RetainEvent(PublishOptions options, Action <IRemoteWampTopicSubscriber, EventDetails> action) { Array[] all = { options.ExcludeAuthenticationIds, options.ExcludeAuthenticationRoles, options.Exclude, options.EligibleAuthenticationIds, options.EligibleAuthenticationRoles, options.Eligible }; RetainedEvent retainedEvent = new RetainedEvent(options, action); // If the event has no restrictions, then it is the most recent event. bool hasNoRestrictions = all.All(x => x == null); lock (mLock) { if (hasNoRestrictions) { mRetainedEvents = ImmutableStack <RetainedEvent> .Empty; } mRetainedEvents = mRetainedEvents.Push(retainedEvent); } }
public void Parse_Single_Chain_With_ScopedVariable() { // arrange var pathString = "foo(bar: $fields:foo)"; // act IImmutableStack <SelectionPathComponent> path = SelectionPathParser.Parse(pathString); // assert Assert.Collection(path, segment => { Assert.Equal("foo", segment.Name.Value); Assert.Collection(segment.Arguments, argument => { Assert.Equal("bar", argument.Name.Value); ScopedVariableNode variable = Assert.IsType <ScopedVariableNode>(argument.Value); Assert.Equal("fields", variable.Scope.Value); Assert.Equal("foo", variable.Name.Value); }); }); }
public void Parse_PathWithoutArgs_ThreeComponentsFound() { // arrange var serializedPath = "foo.bar.baz"; // act IImmutableStack <SelectionPathComponent> path = SelectionPathParser.Parse(serializedPath); // assert Assert.Collection(path.Reverse(), t => { Assert.Equal("foo", t.Name.Value); Assert.Empty(t.Arguments); }, t => { Assert.Equal("bar", t.Name.Value); Assert.Empty(t.Arguments); }, t => { Assert.Equal("baz", t.Name.Value); Assert.Empty(t.Arguments); }); }
public void Parse_PathWithVarArgs_ThreeComponentsOneWithVarArgs() { // arrange var serializedPath = "foo(a: $foo:bar).bar.baz"; // act IImmutableStack <SelectionPathComponent> path = SelectionPathParser.Parse(serializedPath); // assert Assert.Collection(path.Reverse(), c => { Assert.Equal("foo", c.Name.Value); Assert.Collection(c.Arguments, a => { Assert.Equal("a", a.Name.Value); Assert.IsType <ScopedVariableNode>(a.Value); var v = (ScopedVariableNode)a.Value; Assert.Equal("foo_bar", v.ToVariableName()); }); }, c => { Assert.Equal("bar", c.Name.Value); Assert.Empty(c.Arguments); }, c => { Assert.Equal("baz", c.Name.Value); Assert.Empty(c.Arguments); }); }
static IImmutableStack <T> GetNextElementInHierarchyCore <T>(IImmutableStack <T> rootStack, Func <T, IList <T> > getChildren, Func <IList <T>, T, int> indedOf, bool skipChildren) where T : class { var currentElement = rootStack.Peek(); var children = getChildren(currentElement); if (!skipChildren && children.Any()) { return(rootStack.Push(children.First())); } var parents = rootStack.Pop(); var parent = parents.FirstOrDefault(); if (parent == null) { return(rootStack); } var neighbors = getChildren(parent); var index = indedOf(neighbors, currentElement); if (index < neighbors.Count - 1) { return(parents.Push(neighbors[index + 1])); } return(GetNextElementInHierarchyCore(parents, getChildren, indedOf, skipChildren: true)); }
public void Setup() { List <string> list = new List <string> { }; Dictionary <string, string> dict = new Dictionary <string, string> { }; for (int i = 0; i < ElementCount; i++) { list.Add($"hello{i}"); dict.Add($"hello{i}", $"world{i}"); } _iimmutablelist = ImmutableList.CreateRange(list); _iimmutablestack = ImmutableStack.CreateRange(list); _iimmutablequeue = ImmutableQueue.CreateRange(list); _iimmutableset = ImmutableHashSet.CreateRange(list); _iimmutabledictionary = ImmutableDictionary.CreateRange(dict); _immutablearray = ImmutableArray.CreateRange(list); _immutablelist = ImmutableList.CreateRange(list); _immutablestack = ImmutableStack.CreateRange(list); _immutablequeue = ImmutableQueue.CreateRange(list); _immutablesortedset = ImmutableSortedSet.CreateRange(list); _immutablehashset = ImmutableHashSet.CreateRange(list); _immutabledictionary = ImmutableDictionary.CreateRange(dict); _immutablesorteddictionary = ImmutableSortedDictionary.CreateRange(dict); _jsonListString = System.Text.Json.JsonSerializer.Serialize(list); _jsonDictString = System.Text.Json.JsonSerializer.Serialize(dict); }
public void TestPush() { int value = Generator.GetInt32(); var stack = ImmutableTreeStack.Create <int>(); Assert.Empty(stack); // Push doesn't change the original stack stack.Push(value); Assert.Empty(stack); stack = stack.Push(value); Assert.Single(stack); Assert.Equal(value, stack.Peek()); int[] expected = { value }; int[] actual = stack.ToArray(); Assert.Equal(expected, actual); // Test through the IImmutableStack<T> interface IImmutableStack <int> immutableStack = stack; immutableStack.Push(Generator.GetInt32()); Assert.Equal(expected, immutableStack); int nextValue = Generator.GetInt32(); immutableStack = immutableStack.Push(nextValue); Assert.Equal(new[] { nextValue, value }, immutableStack); }
private static void UpdateImmutableStack(IImmutableStack <object> stack) { if (!LogicalOperation.IsRunningInAdapter) { CallContext.LogicalSetData(LogicalOperation.CallContextDataSlotName, stack); } }
public void InterfaceCollectionTest() { IImmutableList <int> a = ImmutableList <int> .Empty.AddRange(new[] { 1, 10, 100 }); IImmutableDictionary <int, int> b = ImmutableDictionary <int, int> .Empty.AddRange(new Dictionary <int, int> { { 1, 10 }, { 2, 10 }, { 3, 100 } }); IImmutableSet <int> c = ImmutableHashSet <int> .Empty.Add(1).Add(10).Add(100); IImmutableQueue <int> d = ImmutableQueue <int> .Empty.Enqueue(1).Enqueue(10).Enqueue(100); IImmutableStack <int> e = ImmutableStack <int> .Empty.Push(1).Push(10).Push(100); Convert(a).IsStructuralEqual(a); Convert(b).IsStructuralEqual(b); Convert(c).IsStructuralEqual(c); Convert(d).IsStructuralEqual(d); Convert(e).IsStructuralEqual(e); a = null; b = null; c = null; d = null; e = null; Convert(a).IsNull(); Convert(b).IsNull(); Convert(c).IsNull(); Convert(d).IsNull(); Convert(e).IsNull(); }
public static Tuple <IImmutableStack <T>, T> popUnsafe <T>(IImmutableStack <T> stack) { T value; var newStack = stack.Pop(out value); return(tuple(newStack, value)); }
public int Sum(IImmutableStack<int> stack) => map( pop(stack), (newstack, option) => match(option, Some: value => value + Sum(newstack), None: () => 0 ) );
/// <summary> /// Saves the stack of <see cref="IAmbientDbContext"/> in the storage. /// </summary> /// <param name="stack"> /// The stack of <see cref="IAmbientDbContext"/> to save. /// </param> public void SaveStack(IImmutableStack <IAmbientDbContext> stack) { #if NET451 var crossReferenceKey = _storage.GetValue <ContextualStorageItem>(AmbientDbContextStorageKey.Key); #else var crossReferenceKey = _storage.GetValue <string>(AmbientDbContextStorageKey.Key); #endif // This can only happen if something explicitly calls RemoveValue on the storage. Otherwise, there will // always be a value in storage. if (crossReferenceKey == null) { throw new AmbientDbContextException("Could not find ambient database context stack in the storage."); } IImmutableStack <IAmbientDbContext> value; // Drop the existing key and recreate because the value is immutable #if NET451 if (AmbientDbContextTable.TryGetValue(crossReferenceKey.Value, out value)) { AmbientDbContextTable.Remove(crossReferenceKey.Value); } AmbientDbContextTable.Add(crossReferenceKey.Value, stack); #else if (AmbientDbContextTable.TryGetValue(crossReferenceKey, out value)) { AmbientDbContextTable.Remove(crossReferenceKey); } AmbientDbContextTable.Add(crossReferenceKey, stack); #endif }
private static FieldNode CreateRequestedField( FieldNode requestedField, ref IImmutableStack <SelectionPathComponent> path) { path = path.Pop(out SelectionPathComponent component); string responseName = requestedField.Alias == null ? requestedField.Name.Value : requestedField.Alias.Value; NameNode alias = component.Name.Value.EqualsOrdinal(responseName) ? null : new NameNode(responseName); IReadOnlyList <ArgumentNode> arguments = component.Arguments.Count == 0 ? requestedField.Arguments : RewriteVariableNames(component.Arguments).ToList(); return(new FieldNode ( null, component.Name, alias, requestedField.Directives, arguments, requestedField.SelectionSet )); }
public void TestStackLikeBehavior() { var stack = ImmutableTreeStack.Create <int>(); var reference = new Stack <int>(); for (int i = 0; i < 2 * 4 * 4; i++) { int item = Generator.GetInt32(); stack = stack.Push(item); reference.Push(item); } while (!stack.IsEmpty) { var expected = reference.Peek(); Assert.Equal(expected, stack.Peek()); Assert.Equal(expected, reference.Pop()); IImmutableStack <int> immutableStack = stack; stack = stack.Pop(out int value); Assert.Equal(expected, value); stack.Validate(ValidationRules.None); Assert.Equal(reference, stack); // Test through the IImmutableStack<T> interface (initialized above) immutableStack = immutableStack.Pop(out value); Assert.Equal(expected, value); Assert.Equal(reference, immutableStack); } Assert.Empty(stack); Assert.Empty(reference); }
private void Initialize( IExecutionContext executionContext, FieldSelection fieldSelection, IImmutableStack <object> source, IDictionary <string, object> serializedResult) { _executionContext = executionContext; _serializedResult = serializedResult; _fieldSelection = fieldSelection; IsRoot = true; Path = Path.New(fieldSelection.ResponseName); Source = source; SourceObject = executionContext.Operation.RootValue; ScopedContextData = ImmutableDictionary <string, object> .Empty; _arguments = fieldSelection.CoerceArguments( executionContext.Variables, executionContext.Converter); string responseName = fieldSelection.ResponseName; PropagateNonNullViolation = () => { serializedResult[responseName] = null; }; }
public async Task InvokeAsync(IMiddlewareContext context) { DelegateDirective delegateDirective = context.Field .Directives[DirectiveNames.Delegate] .FirstOrDefault()?.ToObject <DelegateDirective>(); if (delegateDirective != null) { IImmutableStack <SelectionPathComponent> path = delegateDirective.Path is null ? ImmutableStack <SelectionPathComponent> .Empty : SelectionPathParser.Parse(delegateDirective.Path); IReadOnlyQueryRequest request = CreateQuery(context, delegateDirective.Schema, path); IReadOnlyQueryResult result = await ExecuteQueryAsync( context, request, delegateDirective.Schema) .ConfigureAwait(false); UpdateContextData(context, result, delegateDirective); context.Result = new SerializedData( ExtractData(result.Data, path.Count())); ReportErrors(context, result.Errors); } await _next.Invoke(context).ConfigureAwait(false); }
public void Parse_Two_Chain_With_Literal() { // arrange var pathString = "foo(bar: 1).baz(quox: 2)"; // act IImmutableStack <SelectionPathComponent> path = SelectionPathParser.Parse(pathString); // assert Assert.Collection(path.Reverse(), segment => { Assert.Equal("foo", segment.Name.Value); Assert.Collection(segment.Arguments, argument => { Assert.Equal("bar", argument.Name.Value); Assert.Equal("1", argument.Value.Value); }); }, segment => { Assert.Equal("baz", segment.Name.Value); Assert.Collection(segment.Arguments, argument => { Assert.Equal("quox", argument.Name.Value); Assert.Equal("2", argument.Value.Value); }); }); }
public IEnumerator <T> GetEnumerator() { for (IImmutableStack <T> stack = this; !stack.IsEmpty; stack = stack.Pop()) { yield return(stack.Peek()); } }
public static IImmutableStack <T> Pop <T>(this IImmutableStack <T> stack, out T value) { Requires.NotNull(stack, nameof(stack)); value = stack.Peek(); return(stack.Pop()); }
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()); }
/// <summary> /// Runs when the entire object graph has been deserialized. /// </summary> /// <param name="sender">Unused</param> public void OnDeserialization(object sender) { Stack <TValue> deserializedValues = (Stack <TValue>)m_serializationInfo.GetValue(SerializedFieldName, typeof(Stack <TValue>)); m_store = ImmutableStack.CreateRange(deserializedValues); m_serializationInfo = null; }
public static IImmutableStack <T> Pop <T>(this IImmutableStack <T> stack, out T value) { //Assert.IsNotNull(stack, nameof(stack)); Contract.Ensures(Contract.Result <IImmutableStack <T> >() != null); value = stack.Peek(); return(stack.Pop()); }
public TestClass(IImmutableDictionary <int, int> dictionary, IImmutableList <string> list, IImmutableQueue <string> queue, IImmutableSet <string> sortedSet, IImmutableSet <string> hashSet, IImmutableStack <string> stack) { Dictionary = dictionary; List = list; Queue = queue; SortedSet = sortedSet; HashSet = hashSet; Stack = stack; }
/// <summary> /// A test for Empty /// </summary> /// <typeparam name="T">The type of elements held in the stack.</typeparam> private void EmptyTestHelper <T>() where T : new() { IImmutableStack <T> actual = ImmutableStack <T> .Empty; Assert.NotNull(actual); Assert.True(actual.IsEmpty); AssertAreSame(ImmutableStack <T> .Empty, actual.Clear()); AssertAreSame(ImmutableStack <T> .Empty, actual.Push(new T()).Clear()); }
public static void WritePrimitiveIImmutableStackT() { IImmutableStack <int> input = ImmutableStack.CreateRange(new List <int> { 1, 2 }); string json = JsonSerializer.Serialize(input); Assert.Equal("[2,1]", json); }
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 RemoteQueryBuilder SetSelectionPath( IImmutableStack <SelectionPathComponent> selectionPath) { if (selectionPath == null) { throw new ArgumentNullException(nameof(selectionPath)); } _path = selectionPath; return(this); }
public void Popping5(IImmutableStack<int> test) { test = map(pop(test), (stack, value) => { Assert.IsTrue(value.IsSome); return stack; }); test = map(pop(test), (stack, value) => { Assert.IsTrue(value.IsSome); return stack; }); test = map(pop(test), (stack, value) => { Assert.IsTrue(value.IsSome); return stack; }); test = map(pop(test), (stack, value) => { Assert.IsTrue(value.IsSome); return stack; }); match(peek(test), Some: v => Assert.IsTrue(v == 1), None: () => Assert.Fail() ); }
public static Option <T> peek <T>(IImmutableStack <T> stack) { try { return(Some(stack.Peek())); } catch (InvalidOperationException) { return(None); } }