public void StackTest() { var stack = new LinkedListStack <int>(); //insert 1 to 10 into stack for (int i = 1; i <= 10; i++) { stack.Push(i); } //size should be 10 Assert.Equal(10, stack.Size()); //pop items and assert to ensure FIFO for (int i = 10; i > 0; i--) { var value = stack.Pop(); Assert.Equal(i, value); } //size should be 0 Assert.Equal(0, stack.Size()); //poping on empty stack should throw an exception Assert.Throws <InvalidOperationException>(() => stack.Pop()); }
private LinkedListStack <Node> SelectNodes(RelayMessage message) { LinkedListStack <Node> nodes; List <Node> zoneNodes = _nodesByZone[Me.Zone]; if (zoneNodes != null) { // select all other nodes in the current zone if they exist nodes = new LinkedListStack <Node>(zoneNodes); } else { nodes = new LinkedListStack <Node>(); } if (message.SourceZone == Me.Zone) { // Add 1 node from each foreign zone for (ushort zone = 0; zone < _nodesByZone.Length; zone++) { if (zone != Me.Zone) { Node ZoneNode = GetChosenZoneNode(zone); if (ZoneNode != null) { nodes.Push(ZoneNode); } } } } return(nodes); }
public void LinkedListStackTest() { var stack = new LinkedListStack <int>(); stack.Push(1); stack.Push(2); Assert.IsTrue(stack.ItemCount == 2); Assert.IsTrue(stack.IsEmpty() == false); Assert.IsTrue(stack.Peek() == 2); Assert.IsTrue(stack.Pop() == 2); Assert.IsTrue(stack.ItemCount == 1); stack.Pop(); Assert.IsTrue(stack.IsEmpty()); for (int i = 0; i < 1000; i++) { stack.Push(i); } Assert.IsTrue(stack.ItemCount == 1000); for (int i = 0; i < 1000; i++) { stack.Pop(); } Assert.IsTrue(stack.ItemCount == 0); }
private static string DescribeDestinations(LinkedListStack <Node> destinations) { if (destinations == null || destinations.Count == 0) { return("nowhere"); } StringBuilder sb = new StringBuilder(); sb.Append("to "); sb.Append(destinations.Count); sb.Append(" nodes:"); Node[] nodes = destinations.PeekAll(); foreach (Node node in nodes) { sb.Append(Environment.NewLine); sb.Append(" *"); sb.Append(node.NodeGroup.GroupName); sb.Append(" "); sb.Append(node.Host); sb.Append(":"); sb.Append(node.Port); } return(sb.ToString()); }
private void GeneratePopulatedExample() { PopulatedLinkedListStack = new LinkedListStack <string>(); foreach (var item in Items) { PopulatedLinkedListStack.Push(item); } }
public void Count_PushOneItem_ReturnsOne() { var stack = new LinkedListStack <int>(); stack.Push(1); Assert.AreEqual(1, stack.Count); Assert.IsFalse(stack.IsEmpty); }
public void LinkedListStackWorksInLifoOrder() { var sut = new LinkedListStack <int>(); sut.Push(1); sut.Push(2); Assert.Equal(2, sut.Pop()); }
public void Peek_PushTwoItemsAndPop_ReturnsHeadElement() { var stack = new LinkedListStack <int>(); stack.Push(1); stack.Push(2); stack.Pop(); Assert.AreEqual(1, stack.Peek()); }
public void LinkedListStackIsEnptyWhenAllElementsAreRemoved() { var sut = new LinkedListStack <int>(); sut.Push(1); sut.Push(2); Assert.Equal(2, sut.Pop()); Assert.Equal(1, sut.Pop()); Assert.True(sut.IsEmpty); }
public void LinkedListStackIncreasesCapacityOnDemand() { var sut = new LinkedListStack <int>(); sut.Push(1); sut.Push(2); Assert.Equal(2, sut.Pop()); Assert.Equal(1, sut.Pop()); Assert.True(sut.IsEmpty); }
public void LinkedListStackPushTest() { var linkedListStackStack = new LinkedListStack <int>(); for (var i = 0; i < Elements; i++) { linkedListStackStack.Push(i * 10); } Assert.AreEqual(1000000000, linkedListStackStack.Peek()); }
public override void Init() { _arrayStack = new ArrayStack <int>(100); _linkedListStackStack = new LinkedListStack <int>(); for (var i = 0; i < Elements; i++) { _arrayStack.Push(i * 10); _linkedListStackStack.Push(i * 10); } base.Init(); }
public void TestLinkedListStack() { var stack = new LinkedListStack <int>(); for (var i = 0; i < 5; i++) { stack.Push(i); Console.WriteLine(stack); } stack.Pop(); Console.WriteLine(stack); }
[Test] // 1.3.12 public void CopyStack() { var input = new LinkedListStack <string>(); input.Push("three"); input.Push("two"); input.Push("one"); Assert.AreEqual(new string[] { "one", "two", "three" }, input.ToArray()); var output = CopyStack(input); Assert.AreEqual(output.ToArray(), input.ToArray()); }
internal LinkedListStack <Node> GetNodesForMessage(RelayMessage message) { if (!Activated) { return(new LinkedListStack <Node>()); } NodeCluster cluster; LinkedListStack <Node> nodes; //messages that, from out of system, go to each cluster if (message.IsClusterBroadcastMessage) { if (MyCluster == null) //out of system, each cluster { nodes = new LinkedListStack <Node>(); for (int clusterIndex = 0; clusterIndex < Clusters.Count; clusterIndex++) { nodes.Push(Clusters[clusterIndex].GetNodesForMessage(message)); } } else //in system, my cluster { nodes = MyCluster.GetNodesForMessage(message); } } else { //messages that route to one modded cluster //to modded cluster in group cluster = GetClusterForId(message.Id, message.IsInterClusterMsg); if (cluster != null) { if (message.IsInterClusterMsg && cluster.MeInThisCluster) { nodes = new LinkedListStack <Node>(); nodes.Push(cluster.Me); } else { nodes = cluster.GetNodesForMessage(message); } } else { nodes = new LinkedListStack <Node>(); } } return(nodes); }
public static void LinkedListStack() { LinkedListStack <int> linkedListStack = new LinkedListStack <int>(); linkedListStack.Push(10); linkedListStack.Push(9); linkedListStack.Push(8); linkedListStack.Push(7); linkedListStack.Push(6); linkedListStack.Push(5); linkedListStack.PrintAll(); linkedListStack.Pop(); linkedListStack.Pop(); linkedListStack.PrintAll(); Console.Read(); }
public void LinkedLinkStack() { var stack = new LinkedListStack <string>(); stack.Push("turtles"); stack.Push("all"); stack.Push("the"); stack.Push("way"); stack.Push("down"); Assert.AreEqual("down", stack.Pop()); Assert.AreEqual("way", stack.Pop()); Assert.AreEqual("the", stack.Pop()); Assert.AreEqual("all", stack.Pop()); Assert.AreEqual("turtles", stack.Pop()); }
private Stack <string> CopyStack(Stack <string> source) { var reverse = new LinkedListStack <string>(); var output = new LinkedListStack <string>(); foreach (var item in source) { reverse.Push(item); } foreach (var item in reverse) { output.Push(item); } return(output); }
/// <summary> /// Begins asynchronous processing of a single <see cref="T:MySpace.DataRelay.RelayMessage"/>. /// </summary> /// <param name="message">The <see cref="T:MySpace.DataRelay.RelayMessage"/>.</param> /// <param name="state">Callers can put any state they like here.</param> /// <param name="callback">The method to call upon completion.</param> /// <returns> /// Returns an <see cref="T:System.IAsyncResult"/>. /// </returns> public virtual IAsyncResult BeginHandleMessage(RelayMessage message, object state, AsyncCallback callback) { if (!message.IsTwoWayMessage) { // cheat for now and just handle in messages synchronously // as long as the type doesn't use sync in messages then // we won't block on IO anyway. HandleMessage(message); return(SynchronousAsyncResult.CreateAndComplete(callback, state)); } LinkedListStack <Node> nodes = PrepareMessage(message); Node node; if (nodes.Pop(out node)) { var result = new AsynchronousResult <Node>((ar, n, m) => { try { n.EndHandleOutMessage(ar); RetryHandleMessageOnError(message, node); } catch (Exception ex) { log.Error(ex); } }, node, message); var origCallback = callback; if (callback != null) { callback = ar => { result.InnerResult = ar; origCallback(result); }; } result.InnerResult = node.BeginHandleOutMessage(message, callback, state); return(result); } message.SetError(RelayErrorType.NoNodesAvailable); return(SynchronousAsyncResult.CreateAndComplete(callback, state)); }
private void Dispose() { ClearThreads(); _parallelThreads = _parallelThreads.DisposeExchange(); _executionPathQueueBuilder = _executionPathQueueBuilder.DisposeExchange(); _currentThread.Dispose(this); _currentThread = Thread.Empty; _executionMethods = null; _partialRun = false; Context.ProcessField = DummyProcess; Context = null; _processResources = null; _automata.ReleaseProcess(this); }
public void Push(T val) { ++Count; LinkedListStack <T> stack; if (_stacks.Count == 0 || _stacks[_stacks.Count - 1].Count == Threshold) { stack = new LinkedListStack <T>(); _stacks.Add(stack); } else { stack = _stacks[_stacks.Count - 1]; } stack.Push(val); }
public static void Main(string[] args) { var llStack = new LinkedListStack(); llStack.Print(); llStack.Pop(); llStack.Push(30); llStack.Push(20); llStack.Print(); llStack.Push(50); llStack.Push(120); llStack.Print(); llStack.Pop(); llStack.Pop(); llStack.Print(); llStack.Search(20); }
public void LinkedListStack() { Random random = new Random(); LinkedListStack <string> Stacklist = new LinkedListStack <string>(); for (int i = 0; i < CountItems; i++) { Stacklist.Push($"{i.ToString()}"); } for (int i = 0; i < CountItems; i++) { if (random.Next(i - RndMax, i + RndMin) == i) { Stacklist.Pop(); } } }
private static LinkedListStack <Node> PrepareMessage(RelayMessage message) { LinkedListStack <Node> nodes = NodeManager.Instance.GetNodesForMessage(message); message.RelayTTL--; SetHydrationPolicy(message); if (nodes.Count > 0) { System.Net.IPAddress myAddress = NodeManager.Instance.MyIpAddress; if (myAddress != null) { message.AddAddressToHistory(myAddress); } } DebugWriter.WriteDebugInfo(message, nodes); return(nodes); }
public decimal EvaluatePostfix(string input) { LinkedListStack <decimal> stack = new LinkedListStack <decimal>(); foreach (var i in input) { if (IsOperator(i)) { decimal result; var right = decimal.Parse(stack.Pop().ToString()); var left = decimal.Parse(stack.Pop().ToString()); switch (i) { case '+': result = left + right; break; case '-': result = left - right; break; case '*': result = left * right; break; case '/': result = left / right; break; default: result = 0; break; } stack.Push(result); } else { stack.Push(decimal.Parse(i.ToString())); } } return(stack.First()); }
internal void Add(RelayMessage message, LinkedListStack <Node> nodes) { TypeSetting typeSetting = NodeManager.Instance.Config.TypeSettings.TypeSettingCollection[message.TypeId]; Node node; while (nodes.Pop(out node)) { bool typesettingThrowOnSyncFailure = false; bool typesettingSyncInMessages = false; if (null != typeSetting && !node.NodeCluster.MeInThisCluster) { typesettingSyncInMessages = typeSetting.SyncInMessages; typesettingThrowOnSyncFailure = typeSetting.ThrowOnSyncFailure; } // Contains no longer works now that the NodeWithMessages structure has // been added, loop through and check the settings bool bAdded = false; foreach (NodeWithMessages nwm in this) { NodeWithInfo nwi = GetKeyForItem(nwm); if ((nwi.Node == node) && (nwi.SyncInMessages == typesettingSyncInMessages) && (nwi.SkipErrorQueueForSync == typesettingThrowOnSyncFailure)) { bAdded = true; this[nwi].Messages.Add(message); break; } } if (!bAdded) { NodeWithInfo newNWI = new NodeWithInfo(node, typesettingSyncInMessages, typesettingThrowOnSyncFailure); NodeWithMessages newNode = new NodeWithMessages(newNWI); Add(newNode); this[newNWI].Messages.Add(message); } } }
internal void Initialize(IInstructionReader instructionReader, AutomataContext context) { if (ReferenceEquals(context.ProcessField, DummyProcess) == false) { throw new InvalidOperationException("Context is busy"); } _processResources = ProcessResources.ThreadLocalInstance.Value; _executionPathQueueBuilder = _processResources.ExecutionPathGroupBuilderPool.Get().AddReference(); _parallelThreads = _processResources.ThreadListPool.Get().AddReference(); _executionMethods = _automata.GetExecutionMethods(context); Context = context; Context.ProcessField = this; var entryPoint = context.EntryPoint; if (!(entryPoint is FiniteState state)) { return; } var instructionQueue = _processResources.InstructionQueuePool.Get().Mount(instructionReader, _automata); _entryPointSubGraph = _automata.EnsureSubGraph(state); var initNode = _entryPointSubGraph.InitNode; if (initNode.Safe == false) { initNode.MakeSafe(); } _currentThread = new Thread(initNode, instructionQueue, context.CreateContextStateInternal()) { Stack = _processResources.StackPool.Get().AddReference(), ExecutionQueue = _processResources.ExecutionPathPool.Get().AddReference(), PredicateResultQueue = _processResources.PredicateResultPool.Get().AddReference() }; }
static void Main(string[] args) { var arrayStack = new ArrayStack <string>(); arrayStack.Push("first"); arrayStack.Push("second"); arrayStack.Push("third"); arrayStack.Push("forth"); arrayStack.Pop(); arrayStack.Pop(); arrayStack.Pop(); var linkedListStack = new LinkedListStack <string>(); linkedListStack.Push("first"); linkedListStack.Push("second"); linkedListStack.Push("third"); linkedListStack.Push("forth"); linkedListStack.Pop(); linkedListStack.Pop(); linkedListStack.Pop(); }
private string ShuntingYard(string input) { LinkedListStack <char> operators = new LinkedListStack <char>(); Queue <char> output = new LinkedListQueue <char>(); foreach (var i in input) { if (Char.IsNumber(i)) { output.Enqueue(i); } if (IsOperator(i)) { while (!operators.IsEmpty() && OperatorPrecedence(operators.Peek()) >= OperatorPrecedence(i)) { output.Enqueue(operators.Pop()); } operators.Push(i); } if (i == '(') { operators.Push(i); } if (i == ')') { while (operators.Peek() != '(') { output.Enqueue(operators.Pop()); } operators.Pop(); } } while (!operators.IsEmpty()) { output.Enqueue(operators.Pop()); } return(new string(output.ToArray())); }
static void Main(string[] args) { LinkedList list = new LinkedList(); LinkedListStack stack = new LinkedListStack(); LinkedListQueue queue = new LinkedListQueue(); list.Add(56); list.Add(70); list.Add(90); list.Add(12); list.Add(30); list.Add(60); list.AddInReverseOrder(22); list.AddInReverseOrder(44); list.InsertAtParticularPosition(2, 12); list.Display(); list.Total(); list.DeleteFirst(); list.DeleteLast(); list.SearchValueInList(90); stack.Push(10); stack.Push(20); stack.Push(30); stack.Push(40); stack.Push(50); stack.Display(); stack.Peek(); stack.Pop(); stack.IsEmpty(); queue.Enqueue(12); queue.Enqueue(24); queue.Enqueue(36); queue.Enqueue(48); queue.Dequeue(); queue.Display(); Console.ReadKey(); }
public void SortByDroid() { LinkedListStack<AstromechDroid> astromechList = new LinkedListStack<AstromechDroid>(); LinkedListStack<JanitorDroid> janitorList = new LinkedListStack<JanitorDroid>(); LinkedListStack<ProtocolDroid> protocolList = new LinkedListStack<ProtocolDroid>(); LinkedListStack<UtilityDroid> utilityList = new LinkedListStack<UtilityDroid>(); LinkedListQueue<IDroid> tempList = new LinkedListQueue<IDroid>(); foreach(Droid d in droidCollection) { if(d is AstromechDroid) { astromechList.Add((AstromechDroid)d); } else if(d is JanitorDroid) { janitorList.Add((JanitorDroid)d); } else if(d is ProtocolDroid) { protocolList.Add((ProtocolDroid)d); } else if(d is UtilityDroid) { utilityList.Add((UtilityDroid)d); } } while(astromechList.lastNode.Tail != null) { tempList.Enqueue(astromechList.PopOff()); } tempList.Enqueue(astromechList.PopOff()); while(janitorList.lastNode.Tail != null) { tempList.Enqueue(janitorList.PopOff()); } tempList.Enqueue(janitorList.PopOff()); while(protocolList.lastNode.Tail != null) { tempList.Enqueue(protocolList.PopOff()); } tempList.Enqueue(protocolList.PopOff()); while(utilityList.lastNode.Tail != null) { tempList.Enqueue(utilityList.PopOff()); } tempList.Enqueue(utilityList.PopOff()); droidCollection = new IDroid[lengthOfCollection]; int counter = 0; while(counter < lengthOfCollection) { if(tempList.lastNode != null) { droidCollection[counter] = tempList.Dequeue(); counter++; } } }