/// <summary> /// 创建预制体 /// </summary> /// <param name="Prefab">预制体</param> /// <param name="m_transPerfab">预制体父物体的transform</param> /// <returns></returns> public GameObject CreatePreObj(GameObject Prefab, Transform m_transPerfab) { GameObject obj = null; if (m_queue_gPreObj.Count > 0) { obj = m_queue_gPreObj.Dequeue(); } else { Transform trans = null; trans = GameObject.Instantiate(Prefab, m_transPerfab).transform; //trans.localPosition = Vector3.zero; trans.localRotation = Quaternion.identity; trans.localScale = Vector3.one; obj = trans.gameObject; obj.SetActive(false); } return(obj); }
public string ToStringByLevel() { if (root == null) { return("[]"); } System.Collections.Generic.Queue <BinarySearchTreeNode <T> > queue = new System.Collections.Generic.Queue <BinarySearchTreeNode <T> >(count); string[] arr = new string[count]; queue.Enqueue(root); queue.Enqueue(null); BinarySearchTreeNode <T> current; int pos = 0; while (true) { current = queue.Dequeue(); if (current != null) { arr[pos++] = current.Value.ToString(); if (current.Left != null) { queue.Enqueue(current.Left); } if (current.Right != null) { queue.Enqueue(current.Right); } } else { if (queue.Count == 0) { break; } queue.Enqueue(null); } } return($"[{string.Join(",", arr)}]"); }
public int MinDepth(Node Root) { /* * Level Order traversal * Maintain level. * When find first leaf return */ System.Collections.Generic.Queue <Node> queue = new System.Collections.Generic.Queue <Node>(); System.Collections.Generic.Queue <int> levels = new System.Collections.Generic.Queue <int>(); queue.Enqueue(Root); levels.Enqueue(1); int min = int.MaxValue; while (queue.Count > 0) { Node node = queue.Dequeue(); int level = levels.Dequeue(); if (node.Left == null && node.Right == null) { return(level); } if (node.Left != null) { queue.Enqueue(node.Left); levels.Enqueue(level + 1); } if (node.Right != null) { queue.Enqueue(node.Right); levels.Enqueue(level + 1); } } return(min); }
//BFS, three methods: // 2 queues // 1 queue + dummy node // 1 queue (best) //Maintain one queue public IEnumerable <Node <T, U> > BFS() { var queue = new System.Collections.Generic.Queue <Node <T, U> >(); var currentNode = _root; queue.Enqueue(currentNode); while (queue.Count != 0) { currentNode = queue.Dequeue(); yield return(currentNode); if (currentNode.HasLeftChild()) { queue.Enqueue(currentNode.LeftChild); } if (currentNode.HasRightChild()) { queue.Enqueue(currentNode.RightChild); } } }
/// <summary> /// Writes data from the waitingPoints queue to disk. The waitingPoints queue will be automatically updated whenever reporters report data. /// /// DoWrite() will also be automatically be called periodically according to the settings in the component inspector window, but you can invoke this manually if desired. /// </summary> public void DoWrite() { while (waitingPoints.Count > 0) { string directory = UnityEPL.GetDataPath(); System.IO.Directory.CreateDirectory(directory); string filePath = System.IO.Path.Combine(directory, "unnamed_file"); DataPoint dataPoint = waitingPoints.Dequeue(); string writeMe = "unrecognized type"; string extensionlessFileName = "session";//DataReporter.GetStartTime ().ToString("yyyy-MM-dd HH mm ss"); switch (outputFormat) { case FORMAT.JSON_LINES: writeMe = dataPoint.ToJSON(); filePath = System.IO.Path.Combine(directory, extensionlessFileName + ".jsonl"); break; } System.IO.File.AppendAllText(filePath, writeMe + System.Environment.NewLine); } }
public static IEnumerable <GraphNode> BreadthSearch(GraphNode startGraphNode) { var visited = new HashSet <GraphNode>(); var queue = new System.Collections.Generic.Queue <GraphNode>(); queue.Enqueue(startGraphNode); while (queue.Count != 0) { var node = queue.Dequeue(); if (visited.Contains(node)) { continue; } visited.Add(node); yield return(node); foreach (var incidentNode in node.Edges) { queue.Enqueue(incidentNode); } } }
public void process() { Calc myCalc = new Calc(); FSM myFSM = new FSM(); int count = _q.Count; Input_Data tmpData; for (int i = 0; i < count; i++) { tmpData = _q.Dequeue(); System.Console.Write("SeqNum: {0} ", tmpData.seqNum); if (tmpData.type.Equals(typeof(Calc_Data))) { myCalc.doWork((Calc_Data)tmpData.data); } else if (tmpData.type.Equals(typeof(FSM_Data))) { myFSM.doWork((FSM_Data)tmpData.data); } } }
public List <GraphNode <T> > Flatten() { System.Collections.Generic.Queue <GraphNode <T> > q = new System.Collections.Generic.Queue <GraphNode <T> >(); HashSet <GraphNode <T> > visited = new HashSet <GraphNode <T> >(); q.Enqueue(this); while (q.Count != 0) { GraphNode <T> node = q.Dequeue(); if (!visited.Contains(node)) { visited.Add(node); foreach (GraphNode <T> n in node.Neighbours) { q.Enqueue(n); } } } return(visited.ToList()); }
public bool TryDequeue(out LoggingEvent msg) { // If the queue is empty, wait for an item to be added // Note that this is a while loop, as we may be pulsed // but not wake up before another thread has come in and // consumed the newly added object. In that case, we'll // have to wait for another pulse. msg = null; var result = false; if (queue.Count > 0) { using (locker.Using()) { if (queue.Count > 0) { msg = queue.Dequeue(); result = true; } } } return(result); }
public List <List <T> > LevelOrderArrayByLevels() { System.Collections.Generic.Queue <Node> queue = new System.Collections.Generic.Queue <Node>(); List <List <T> > res = new List <List <T> >(); queue.Enqueue(Root); while (true) { if (queue.Count == 0) { break; } int nodeCount = queue.Count; List <T> level = new List <T>(); while (nodeCount > 0) { Node node = queue.Dequeue(); level.Add(node.Value); if (node.Left != null) { queue.Enqueue(node.Left); } if (node.Right != null) { queue.Enqueue(node.Right); } nodeCount--; } res.Add(level); } return(res); }
public bool TryFindValue(T value, out GetIndex <K> point) { if (_root == null) { point = null; return(false); } // First-in, First-out list of nodes to search var nodesToSearch = new System.Collections.Generic.Queue <Node>(); nodesToSearch.Enqueue(_root); while (nodesToSearch.Count > 0) { var nodeToSearch = nodesToSearch.Dequeue(); if (nodeToSearch.Value.Equals(value)) { point = this._locate(nodeToSearch.Value); return(true); } else { if (nodeToSearch.LeftChild != null) { nodesToSearch.Enqueue(nodeToSearch.LeftChild); } if (nodeToSearch.RightChild != null) { nodesToSearch.Enqueue(nodeToSearch.RightChild); } } } point = null; return(false); }
private void NextInQueue() { lock (LockPoint) { bool stop; do { if (_lockQueue.Count > 0) { var result = _lockQueue.Dequeue(); stop = result.TrySetResult(true); } else { stop = true; } if (_lockQueue.Count == 0 && !_keepQueueIfEmpty) // clear queue { LockPointsDictionary.Remove(_lockPointObject); } } while (!stop); } }
/// <summary> /// // to refresh your mind check video # 75, 76 in Mosh data-structure course part II /// </summary> /// <param name="label"></param> /// <returns></returns> public IList <string> TraverseBreadthFirst(string label) { var values = new List <string>(); if (!_nodes.TryGetValue(label, out Node node)) { return(values); } var visitedNodes = new HashSet <Node>(); var queue = new System.Collections.Generic.Queue <Node>(); queue.Enqueue(node); while (queue.Count > 0) { var current = queue.Dequeue(); if (visitedNodes.Contains(current)) { continue; } values.Add(current.Label); visitedNodes.Add(current); foreach (var neighbor in _adjacencyList[current]) { // we traverse a node only if it is not visited before if (!visitedNodes.Contains(neighbor)) { queue.Enqueue(neighbor); } } } return(values); }
void worker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e) { ImageDetail[] iconImgs = e.Result as ImageDetail[]; if (iconImgs.Length > 0) { if (screen.SelectedCamera.ID == -1 || screen.SelectedCamera.ID == iconImgs[0].FromCamera) { screen.ShowImages(iconImgs); } } if (imgsQueue.Count > 0) { screen.ShowProgress = true; worker.RunWorkerAsync(imgsQueue.Dequeue()); } else { screen.ShowProgress = false; } }
/// <summary> /// BFS provides us with the ability to return the same results as DFS but with the added guarantee to return the shortest-path first, based on number of edges being the cost factor. This algorithm us queue instead of stack. /// </summary> /// <param name="start"></param> /// <returns></returns> public IEnumerable <Vertex <T> > BFS_Visit(T start) { var startVert = GetVertex(start); var visited = new HashSet <Vertex <T> >(); //change stack to queue var queue = new System.Collections.Generic.Queue <Vertex <T> >(); queue.Enqueue(startVert); while (queue.Count != 0) { var currentVert = queue.Dequeue(); if (!visited.Add(currentVert)) { continue; } var unvisitNbr = currentVert.GetConnections().Where(n => !visited.Contains(n)); foreach (var next in unvisitNbr.Reverse()) { queue.Enqueue(next); } } return(visited); }
public List <GraphNode <T> > FindPath(GraphNode <T> start, GraphNode <T> end) { var path = new Dictionary <GraphNode <T>, GraphNode <T> > { [start] = null }; var queue = new System.Collections.Generic.Queue <GraphNode <T> >(); queue.Enqueue(start); while (queue.Count != 0) { var node = queue.Dequeue(); foreach (var next in node._incidentNodes) { if (path.ContainsKey(next)) { continue; } path[next] = node; queue.Enqueue(next); } if (path.ContainsKey(end)) { break; } } var pathItem = end; var result = new List <GraphNode <T> >(); while (pathItem != null) { result.Add(pathItem); pathItem = path[pathItem]; } result.Reverse(); return(result); }
private Message GetNextMessage(int millis) { if (forwarder != null) { throw new InvalidOperationException("Invokeable has a task attached"); } if (thread == null) { AttachCurrentThread(); } if (sem.WaitOne(millis, false)) { lock (queue) { return(queue.Dequeue()); } } else { return(null); } }
private static IEnumerable <Point> GetPath(Labyrint labyrint, Point from, Point to, int bombCount) { var visited = new HashSet <Point>(); var queue = new System.Collections.Generic.Queue <State>(); var ways = new Dictionary <Point, Point>(); queue.Enqueue(new State(from, null, bombCount)); while (queue.Count != 0) { var currentState = queue.Dequeue(); visited.Add(currentState.Point); var neighbours = GetNeighbours(currentState.Point) .Where(x => !visited.Contains(x) && BelongsToLabyrint(labyrint, x)); foreach (var point in neighbours) { ways[point] = currentState.Point; if (!labyrint.IsWall(point)) { queue.Enqueue(new State(point, currentState, currentState.BombCount)); } else if (currentState.BombCount > 0) { queue.Enqueue(new State(point, currentState, currentState.BombCount - 1)); } if (point.Equals(to)) { return(BuildPath(currentState)); } } } return(null); }
private void EmitPendingBuffers(bool doAll, bool mustWait) { // When combining parallel deflation with a ZipSegmentedStream, it's // possible for the ZSS to throw from within this method. In that // case, Close/Dispose will be called on this stream, if this stream // is employed within a using or try/finally pair as required. But // this stream is unaware of the pending exception, so the Close() // method invokes this method AGAIN. This can lead to a deadlock. // Therefore, failfast if re-entering. if (emitting) { return; } emitting = true; if ((doAll && (_latestCompressed != _lastFilled)) || mustWait) { _newlyCompressedBlob.WaitOne(); } do { int firstSkip = -1; int millisecondsToWait = doAll ? 200 : (mustWait ? -1 : 0); int nextToWrite = -1; do { if (Monitor.TryEnter(_toWrite, millisecondsToWait)) { nextToWrite = -1; try { if (_toWrite.Count > 0) { nextToWrite = _toWrite.Dequeue(); } } finally { Monitor.Exit(_toWrite); } if (nextToWrite >= 0) { WorkItem workitem = _pool[nextToWrite]; if (workitem.ordinal != _lastWritten + 1) { // out of order. requeue and try again. TraceOutput(TraceBits.EmitSkip, "Emit skip wi({0}) ord({1}) lw({2}) fs({3})", workitem.index, workitem.ordinal, _lastWritten, firstSkip); lock (_toWrite) { _toWrite.Enqueue(nextToWrite); } if (firstSkip == nextToWrite) { // We went around the list once. // None of the items in the list is the one we want. // Now wait for a compressor to signal again. _newlyCompressedBlob.WaitOne(); firstSkip = -1; } else if (firstSkip == -1) { firstSkip = nextToWrite; } continue; } firstSkip = -1; TraceOutput(TraceBits.EmitBegin, "Emit begin wi({0}) ord({1}) cba({2})", workitem.index, workitem.ordinal, workitem.compressedBytesAvailable); _outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable); _runningCrc.Combine(workitem.crc, workitem.inputBytesAvailable); _totalBytesProcessed += workitem.inputBytesAvailable; workitem.inputBytesAvailable = 0; TraceOutput(TraceBits.EmitDone, "Emit done wi({0}) ord({1}) cba({2}) mtw({3})", workitem.index, workitem.ordinal, workitem.compressedBytesAvailable, millisecondsToWait); _lastWritten = workitem.ordinal; _toFill.Enqueue(workitem.index); // don't wait next time through if (millisecondsToWait == -1) { millisecondsToWait = 0; } } } else { nextToWrite = -1; } } while (nextToWrite >= 0); } while (doAll && (_lastWritten != _latestCompressed || _lastWritten != _lastFilled)); emitting = false; }
/** @return the next smallest number */ public int Next() { return(heap.Dequeue()); }
public void mosy_alg() { lbl_info.Text = "Working..."; ///////iniate S ///////////// ArrayList S = new ArrayList(); ArrayList S2 = new ArrayList(); ArrayList mymeans = new ArrayList(); ArrayList border_point = new ArrayList(); S.AddRange(datapoints); r = int.Parse(txt_r.Text); nighbour_min = int.Parse(txt_neigh.Text); //// initiate queue Queue <data> q = new System.Collections.Generic.Queue <data>(); //////Start of algorithm int ci = 1; while (S.Count != 0) { ///// take a data point randomly data dp = take_data_point(S, S2, ci); int cluster_count = 1; int sum_x = 0; int sum_y = 0; if (neigh_count(dp, r) > nighbour_min) { sum_x = dp.point.X; sum_y = dp.point.Y; q.Enqueue(dp); } else { border_point.Add(dp); } while (q.Count != 0) { dp = q.Dequeue(); ArrayList remove_list = new ArrayList(); Boolean nth = false; //if (neigh_count(dp, r) > nighbour_min) nth = true; for (int ii = 0; ii < S.Count; ii++) { try { if (distance(dp.point, ((data)S[ii]).point) <= r) // check the distance from point picked of queue to point in S { // put the point in the queue if (/*nth &&*/ neigh_count((data)S[ii], r) > nighbour_min) { q.Enqueue(((data)S[ii])); //set point's set ((data)S[ii]).set = ci; Graphics gf = pic_pln.CreateGraphics(); Thread.Sleep((5000 - trk_speed.Value) / 5); gf.DrawEllipse(new Pen(colors[(((data)S[ii]).set - 1) % 32], 2f), ((data)S[ii]).point.X - 1, ((data)S[ii]).point.Y - 1, 2, 2); sum_x += ((data)S[ii]).point.X; sum_y += ((data)S[ii]).point.Y; cluster_count++; } else { border_point.Add((data)S[ii]); } // remove from S S2.Add(((data)S[ii])); remove_list.Add(ii); //S.RemoveAt(ii);//S.Remove(((data)S[ii])); } } catch (Exception ee) { MessageBox.Show("error " + ee.Message); } } remove_points_from_S(S, remove_list); } data mi = new data(new Point(sum_x / cluster_count, sum_y / cluster_count), ci); mymeans.Add(mi); ci++; } //clearboard(); Border_coloring(border_point, S2); draw_points(S2, mymeans); lbl_info.Text = "Finished"; }
private void AcquireMarks() { int i; Mark CurrentMark = new Mark(); CurrentMark.Id = -1; EnterState(State.Idle); while (m_State != State.Invalid) { MessageType msg = MessageType.Null; lock (m_Messages) if (m_Messages.Count == 0) { System.Threading.Thread.Sleep(200); if (m_Messages.Count == 0) { msg = MessageType.Null; } else { msg = m_Messages.Dequeue(); } } else { msg = m_Messages.Dequeue(); } switch (m_State) { case State.Idle: if (IsEnteringState) { } switch (msg) { case MessageType.Stop: EnterState(State.Failed); continue; } IEnumerable <Mark> nextmarks = m_Marks.Where(m => m.NotFound == false && (m.XValid == false || m.YValid == false)); if (nextmarks.Count() == 0) { EnterState((m_Marks.Where(m => m.NotFound == false).Count() >= 2) ? State.Done : State.Failed); } else { CurrentMark = nextmarks.First(); SyncCurrentMark(CurrentMark); iStage.PosMove(SySal.StageControl.Axis.X, CurrentMark.ExpectedPos.X, C.XYSpeed, C.XYAcceleration, C.XYAcceleration); iStage.PosMove(SySal.StageControl.Axis.Y, CurrentMark.ExpectedPos.Y, C.XYSpeed, C.XYAcceleration, C.XYAcceleration); EnterState(State.Moving); } break; case State.Moving: if (IsEnteringState) { } switch (msg) { case MessageType.Stop: EnterState(State.Failed); continue; case MessageType.Pause: { iStage.Stop(StageControl.Axis.X); iStage.Stop(StageControl.Axis.Y); iStage.Stop(StageControl.Axis.Z); EnterState(State.PauseMoving); } continue; } { if (Math.Abs(iStage.GetPos(SySal.StageControl.Axis.X) - CurrentMark.ExpectedPos.X) < C.XYPosTolerance && Math.Abs(iStage.GetPos(SySal.StageControl.Axis.Y) - CurrentMark.ExpectedPos.Y) < C.XYPosTolerance) { EnterState(State.Acquiring); } } break; case State.Acquiring: if (IsEnteringState) { } switch (msg) { case MessageType.Stop: EnterState(State.Failed); continue; case MessageType.Pause: EnterState(State.PauseMoving); continue; case MessageType.SetX: { CurrentMark.FoundPos.X = iStage.GetPos(SySal.StageControl.Axis.X); SetText(txtFoundX, CurrentMark.FoundPos.X.ToString("F0", System.Globalization.CultureInfo.InvariantCulture)); CurrentMark.XValid = true; CurrentMark.NotFound = false; SetText(txtFlag, (CurrentMark.XValid && CurrentMark.YValid) ? "Found" : "Not searched"); if (CurrentMark.YValid) { EnterState(State.Idle); } } break; case MessageType.SetY: { CurrentMark.FoundPos.Y = iStage.GetPos(SySal.StageControl.Axis.Y); SetText(txtFoundY, CurrentMark.FoundPos.Y.ToString("F0", System.Globalization.CultureInfo.InvariantCulture)); CurrentMark.YValid = true; CurrentMark.NotFound = false; SetText(txtFlag, (CurrentMark.XValid && CurrentMark.YValid) ? "Found" : "Not searched"); if (CurrentMark.XValid) { EnterState(State.Idle); } } break; case MessageType.SetNotFound: { CurrentMark.XValid = CurrentMark.YValid = false; CurrentMark.NotFound = true; SetText(txtFlag, "Not Found"); EnterState(State.Idle); } break; case MessageType.SetNotSearched: { CurrentMark.XValid = CurrentMark.YValid = false; SetText(txtFlag, "Not Searched"); } break; } { /* no action here */ } break; case State.PauseMoving: if (IsEnteringState) { } switch (msg) { case MessageType.Continue: { if (CurrentMark.NotFound || (CurrentMark.XValid == true && CurrentMark.YValid == true)) { EnterState(State.Idle); } else { iStage.PosMove(SySal.StageControl.Axis.X, CurrentMark.ExpectedPos.X, C.XYSpeed, C.XYAcceleration, C.XYAcceleration); iStage.PosMove(SySal.StageControl.Axis.Y, CurrentMark.ExpectedPos.Y, C.XYSpeed, C.XYAcceleration, C.XYAcceleration); EnterState(State.Moving); } } continue; case MessageType.Stop: EnterState(State.Failed); continue; case MessageType.SetX: { CurrentMark.FoundPos.X = iStage.GetPos(SySal.StageControl.Axis.X); SetText(txtFoundX, CurrentMark.FoundPos.X.ToString("F0", System.Globalization.CultureInfo.InvariantCulture)); CurrentMark.XValid = true; CurrentMark.NotFound = false; SetText(txtFlag, (CurrentMark.XValid && CurrentMark.YValid) ? "Found" : "Not searched"); if (CurrentMark.YValid) { EnterState(State.Idle); } } break; case MessageType.SetY: { CurrentMark.FoundPos.Y = iStage.GetPos(SySal.StageControl.Axis.Y); SetText(txtFoundY, CurrentMark.FoundPos.Y.ToString("F0", System.Globalization.CultureInfo.InvariantCulture)); CurrentMark.YValid = true; CurrentMark.NotFound = false; SetText(txtFlag, (CurrentMark.XValid && CurrentMark.YValid) ? "Found" : "Not searched"); if (CurrentMark.XValid) { EnterState(State.Idle); } } break; case MessageType.SetNotFound: { CurrentMark.XValid = CurrentMark.YValid = false; CurrentMark.NotFound = true; SetText(txtFlag, "Not Found"); EnterState(State.Idle); } break; case MessageType.SetNotSearched: { CurrentMark.XValid = CurrentMark.YValid = false; SetText(txtFlag, "Not Searched"); } break; case MessageType.Next: { int im; for (im = 0; m_Marks[im] != CurrentMark; im++) { ; } if (im < m_Marks.Length - 1) { CurrentMark = m_Marks[im + 1]; SyncCurrentMark(CurrentMark); } } break; case MessageType.Previous: { int im; for (im = 0; m_Marks[im] != CurrentMark; im++) { ; } if (im > 0) { CurrentMark = m_Marks[im - 1]; SyncCurrentMark(CurrentMark); } } break; } { /* no action here */ } break; case State.PauseAcquiring: if (IsEnteringState) { } switch (msg) { case MessageType.Stop: EnterState(State.Failed); continue; } EnterState(State.Acquiring); break; case State.Done: if (IsEnteringState) { iCamDisp.EnableCross = false; } return; case State.Failed: if (IsEnteringState) { iCamDisp.EnableCross = false; } return; default: m_State = State.Invalid; iCamDisp.EnableCross = false; return; } } }
private void HandleEvents() { lock (pendingActions) { while (pendingActions.Count > 0) { var action = pendingActions.Dequeue(); if (action.type == ActionData.Type.Added) { GameObject qrCodeObject = Instantiate(qrCodePrefab, new Vector3(0, 0, 0), Quaternion.identity); qrCodeObject.GetComponent <SpatialGraphNodeTracker>().Id = action.qrCode.SpatialGraphNodeId; qrCodeObject.GetComponent <QRCode>().qrCode = action.qrCode; qrCodesObjectsList.Add(action.qrCode.Id, qrCodeObject); //AROA EDIT - Assign object to QRCode script Debug.Log("Action.qrCode.Data = " + action.qrCode.Data); qrCodeObject.GetComponent <QRCode>().textToSpeech = textToSpeech; qrCodeObject.GetComponent <QRCode>().obstacleManager = obstacleManager; if (action.qrCode.Data == "QR Code 1") { layout = "Layout 1"; } else if (action.qrCode.Data == "QR Code 2") { layout = "Layout 2"; } else if (action.qrCode.Data == "QR Code 3") { layout = "Layout 3"; } else if (action.qrCode.Data == "QR Code 4") { layout = "Layout 4"; } else if (action.qrCode.Data == "QR Code 5") { layout = "Layout 5"; } else if (action.qrCode.Data == "QR Code 6") { layout = "Layout 6"; } else if (action.qrCode.Data == "QR Code 7") { layout = "Layout 7"; } else if (action.qrCode.Data == "QR Code 8") { layout = "Layout 8"; } else if (action.qrCode.Data == "Demo") { layout = "Demo Layout"; } else { layout = "Unrecognized Layout"; } experimentLogger.layout = layout; qrCodeObject.GetComponent <QRCode>().layout = layout; qrCodeObject.GetComponent <QRCode>().trackedObject = obstacleCollection; qrCodeObject.GetComponent <QRCode>().experimentLogger = experimentLogger; //Assign obstacles to QR Code object qrCodeObject.GetComponent <QRCode>().obstLow1 = obstLow1; qrCodeObject.GetComponent <QRCode>().obstLow2 = obstLow2; qrCodeObject.GetComponent <QRCode>().obstHigh1 = obstHigh1; qrCodeObject.GetComponent <QRCode>().obstHigh2 = obstHigh2; qrCodeObject.GetComponent <QRCode>().obstWide1 = obstWide1; qrCodeObject.GetComponent <QRCode>().obstWide2 = obstWide2; } else if (action.type == ActionData.Type.Updated) { if (!qrCodesObjectsList.ContainsKey(action.qrCode.Id)) { GameObject qrCodeObject = Instantiate(qrCodePrefab, new Vector3(0, 0, 0), Quaternion.identity); qrCodeObject.GetComponent <SpatialGraphNodeTracker>().Id = action.qrCode.SpatialGraphNodeId; qrCodeObject.GetComponent <QRCode>().qrCode = action.qrCode; qrCodesObjectsList.Add(action.qrCode.Id, qrCodeObject); //AROA EDIT //QR codes created using https://www.qr-code-generator.com/ Debug.Log("Action.qrCode.Data = " + action.qrCode.Data); qrCodeObject.GetComponent <QRCode>().textToSpeech = textToSpeech; qrCodeObject.GetComponent <QRCode>().obstacleManager = obstacleManager; if (action.qrCode.Data == "QR Code 1") { layout = "Layout 1"; } else if (action.qrCode.Data == "QR Code 2") { layout = "Layout 2"; } else if (action.qrCode.Data == "QR Code 3") { layout = "Layout 3"; } else if (action.qrCode.Data == "QR Code 4") { layout = "Layout 4"; } else if (action.qrCode.Data == "QR Code 5") { layout = "Layout 5"; } else if (action.qrCode.Data == "QR Code 6") { layout = "Layout 6"; } else if (action.qrCode.Data == "QR Code 7") { layout = "Layout 7"; } else if (action.qrCode.Data == "QR Code 8") { layout = "Layout 8"; } else if (action.qrCode.Data == "Demo") { layout = "Demo Layout"; } else { layout = "Unrecognized Layout"; } qrCodeObject.GetComponent <QRCode>().layout = layout; qrCodeObject.GetComponent <QRCode>().trackedObject = obstacleCollection; qrCodeObject.GetComponent <QRCode>().experimentLogger = experimentLogger; //Assign obstacles to QR Code object qrCodeObject.GetComponent <QRCode>().obstLow1 = obstLow1; qrCodeObject.GetComponent <QRCode>().obstLow2 = obstLow2; qrCodeObject.GetComponent <QRCode>().obstHigh1 = obstHigh1; qrCodeObject.GetComponent <QRCode>().obstHigh2 = obstHigh2; qrCodeObject.GetComponent <QRCode>().obstWide1 = obstWide1; qrCodeObject.GetComponent <QRCode>().obstWide2 = obstWide2; } } else if (action.type == ActionData.Type.Removed) { if (qrCodesObjectsList.ContainsKey(action.qrCode.Id)) { Destroy(qrCodesObjectsList[action.qrCode.Id]); qrCodesObjectsList.Remove(action.qrCode.Id); } } } } if (clearExisting) { clearExisting = false; foreach (var obj in qrCodesObjectsList) { Destroy(obj.Value); } qrCodesObjectsList.Clear(); } }
public IValue Dequeue() { return(_queue.Dequeue()); }
public static void Initialize(string signingIdentity, string instanceId) { if (libraryCallbackDelegate == null) { libraryCallbackDelegate = new NdnRtcLibLogHandler(ndnrtcLogHandler); } bool res; try { string version = Marshal.PtrToStringAnsi(NdnRtcWrapper.ndnrtc_getVersion()); Debug.Log("NDN-RTC version " + version); res = NdnRtcWrapper.ndnrtc_init("localhost", Application.persistentDataPath, signingIdentity, instanceId, libraryCallbackDelegate); if (res) { LocalStreamParams p = new LocalStreamParams(); p.basePrefix = signingIdentity + "/" + instanceId; p.signingOn = 1; p.dropFrames = 1; p.fecOn = 1; p.frameHeight = 180; p.frameWidth = 320; p.gop = 30; p.startBitrate = 300; p.maxBitrate = 7000; p.ndnSegmentSize = 8000; p.typeIsVideo = 1; p.streamName = "back_camera"; p.threadName = "vp9"; p.storagePath = Application.persistentDataPath + "/ndnrtc_storage"; videoStream = new LocalVideoStream(p); runFrameFetching_ = true; queueSem_ = new Semaphore(0, 30); // up to 30 requests. why not?... activeTasks_ = new HashSet <FrameFetchingTask>(); frameFetchingTaskQueue_ = new System.Collections.Generic.Queue <FrameFetchingTask>(); frameFetchingThread_ = new Thread(new ThreadStart(delegate() { while (runFrameFetching_) { Debug.Log("[ff-task-worker]: waiting for new tasks..."); // lock on semaphore / event queueSem_.WaitOne(); // deque FrameFetchingTask ffTask = frameFetchingTaskQueue_.Dequeue(); Debug.Log("[ff-task-worker]: running task for " + ffTask.frameName_); activeTasks_.Add(ffTask); ffTask.run(delegate(FrameFetchingTask fft){ Debug.Log("[ff-task-worker]: task completed: " + fft.frameName_); // cleanup when we are done activeTasks_.Remove(fft); }); } // while })); frameFetchingThread_.Start(); } } catch (System.Exception e) { Debug.LogError("Error initializing NDN-RTC: " + e.Message); } }
public override ValidationError ValidateActivityChange(Activity activity, ActivityChangeAction action) { if (activity == null) throw new ArgumentNullException("activity"); if (action == null) throw new ArgumentNullException("action"); AddedActivityAction addedAction = action as AddedActivityAction; if (addedAction != null) { //Check existence of nested PersistOnClose/ICompensatable/SupportsTransaction nested anywhere //in the added activity branch System.Collections.Generic.Queue<Activity> childrenQueue = new System.Collections.Generic.Queue<Activity>(); childrenQueue.Enqueue(addedAction.AddedActivity); while (childrenQueue.Count != 0) { Activity childActivity = childrenQueue.Dequeue(); if (childActivity.SupportsTransaction) return new ValidationError(SR.GetString(SR.Error_AtomicScopeNestedInNonLRT), ErrorNumbers.Error_AtomicScopeNestedInNonLRT); if (childActivity.PersistOnClose) return new ValidationError(SR.GetString(SR.Error_NestedPersistOnClose, activity.QualifiedName), ErrorNumbers.Error_NestedPersistOnClose); if (childActivity is ICompensatableActivity) return new ValidationError(SR.GetString(SR.Error_NestedCompensatableActivity, activity.QualifiedName), ErrorNumbers.Error_NestedCompensatableActivity); CompositeActivity compositeActivity = childActivity as CompositeActivity; if (compositeActivity != null) { foreach (Activity grandChild in compositeActivity.EnabledActivities) { childrenQueue.Enqueue(grandChild); } } } } return base.ValidateActivityChange(activity, action); }
public void pushToNetwork(LocalNetworkGamer localGamer) { int icount = outQ.Count; for (int i = 0; i < icount; i++) { qHeader pHead = outQ.Dequeue(); switch (pHead.type) { case QueueType.ship_rot_anti: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.ship_rot_anti, pHead.outseq, pHead.packetOwner); } break; case QueueType.ship_rot_clock: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.ship_rot_clock, pHead.outseq, pHead.packetOwner); } break; case QueueType.ship_bomb: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.ship_bomb, pHead.outseq, pHead.packetOwner); } break; case QueueType.ship_missile: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.ship_missile, pHead.outseq, pHead.packetOwner); } break; case QueueType.ship_impulse: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.ship_impulse, pHead.outseq, pHead.packetOwner); } break; case QueueType.EventMessage: Send(localGamer, pHead); if (pHead.inseq > 1 || localGamer.IsHost) { inQueue.add(pHead.obj, QueueType.EventMessage, pHead.outseq, pHead.packetOwner); } break; } } }
// PacketWriter packetWriter2 = new PacketWriter(); public static void PushToNetwork() { PacketWriter packetWriter2 = new PacketWriter(); int count = outQ.Count; for (int i = 0; i < count; i++) { // Read the header QueueHdr qH = outQ.Dequeue(); switch (qH.type) { case Queue_type.QUEUE_SHIP_BOMB: packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } } foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) { if (!Game1.networkSession.IsHost) { InputQueue.add(qH); // Write our latest input state into a network packet. //packetWriter2.Write(qH.inSeqNum); //packetWriter2.Write(qH.outSeqNum); //packetWriter2.Write((int)qH.type); // packetWriter2.Write((int)qH.data); // Send our input data to the server.// gamer.SendData(packetWriter2, SendDataOptions.InOrder, Game1.networkSession.Host); } } break; case Queue_type.QUEUE_SHIP_MISSILE: packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } } foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) { if (!Game1.networkSession.IsHost) { InputQueue.add(qH); // Write our latest input state into a network packet. //packetWriter2.Write(qH.inSeqNum); //packetWriter2.Write(qH.outSeqNum); //packetWriter2.Write((int)qH.type); // packetWriter2.Write((int)qH.data); // Send our input data to the server. gamer.SendData(packetWriter2, SendDataOptions.InOrder, Game1.networkSession.Host); } } break; case Queue_type.QUEUE_SHIP_IMPULSE: packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data; packetWriter2.Write((Vector2)sim.impulse); Debug.WriteLine("Outputq - sim.impulse = " + sim.impulse); Debug.WriteLine("Outputq - sim.X = " + sim.impulse.X); Debug.WriteLine("Outputq - sim.Y = " + sim.impulse.Y); if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } } foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) { if (!Game1.networkSession.IsHost) { InputQueue.add(qH); ///just added 207pm // Write our latest input state into a network packet. //packetWriter2.Write(qH.inSeqNum); //packetWriter2.Write(qH.outSeqNum); //packetWriter2.Write((int)qH.type); //Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data; //packetWriter2.Write((Vector2)sim.impulse); // Send our input data to the server. gamer.SendData(packetWriter2, SendDataOptions.InOrder, Game1.networkSession.Host); } } break; case Queue_type.QUEUE_SHIP_ROT: //send to input queue //packetWriter2.Write(qH.inSeqNum); // packetWriter2.Write(qH.outSeqNum); // packetWriter2.Write((int)qH.type); // Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data; // packetWriter2.Write((Vector2)sim.impulse); packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data; packetWriter2.Write(rotMessage.rotation); Debug.WriteLine(" OutputQ - rotMessage.rotation = " + rotMessage.rotation); if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } } if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) { if (!Game1.networkSession.IsHost) { // Write our latest input state into a network packet. //packetWriter2.Write(qH.inSeqNum); //packetWriter2.Write(qH.outSeqNum); //packetWriter2.Write((int)qH.type); //Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data; //packetWriter2.Write(rotMessage.rotation); // packetWriter2.Write((Vector2)qH.data); // Send our input data to the server. gamer.SendData(packetWriter2, SendDataOptions.InOrder, Game1.networkSession.Host); } } break; case Queue_type.QUEUE_PHYSICS_BUFFER: if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } } if (Game1.networkSession != null) { // packetWriter2.Write(gamer.Id); packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); //Debug.WriteLine("qH.inSeqNum from PushToNetwork = " + qH.inSeqNum); //Debug.WriteLine("qH.outSeqNum from PushToNetwork = " + qH.outSeqNum); //Debug.WriteLine("qH.type from PushToNetwork = " + qH.type); //PhysicsBuffer[] localPhysicsBuff = new PhysicsBuffer[]; PhysicsBuffer_Message PhysicsBuff_MessageInQueueHdr = new PhysicsBuffer_Message((PhysicsBuffer_Message)qH.data); //get the count from the buffer packetWriter2.Write(PhysicsBuff_MessageInQueueHdr.count); //Debug.WriteLine("PhysicsBuff_MessageInQueueHdr.count = " + PhysicsBuff_MessageInQueueHdr.count); PhysicsBuffer[] localPhysicsBuff = new PhysicsBuffer[PhysicsBuff_MessageInQueueHdr.count]; //get the the physics buffer struct of id, position , rotation out localPhysicsBuff = PhysicsBuff_MessageInQueueHdr.pBuff; for (int j = 0; j < PhysicsBuff_MessageInQueueHdr.count; j++) { PhysicsBuffer myPhysicsBuffer = new PhysicsBuffer(); myPhysicsBuffer.id = localPhysicsBuff[j].id; myPhysicsBuffer.position = localPhysicsBuff[j].position; myPhysicsBuffer.rotation = localPhysicsBuff[j].rotation; packetWriter2.Write(myPhysicsBuffer.id); packetWriter2.Write(myPhysicsBuffer.position); packetWriter2.Write(myPhysicsBuffer.rotation); //Debug.WriteLine("myPhysicsBuffer.id = " + myPhysicsBuffer.id); //Debug.WriteLine("myPhysicsBuffer.position = " + myPhysicsBuffer.position); //Debug.WriteLine("myPhysicsBuffer.rotation = " + myPhysicsBuffer.rotation); } if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } } // if this is the client machine, need to send to server } // Send our input data to the server. //if (Game1.networkSession != null) //{ // if (Game1.networkSession.IsHost) // { // foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) // { // gamer.SendData(packetWriter2, // SendDataOptions.InOrder, Game1.networkSession.); // } // } //} break; case Queue_type.QUEUE_EVENT: if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { InputQueue.add(qH); } } if (Game1.networkSession != null) { // Write our latest input state into a network packet. packetWriter2.Write(qH.inSeqNum); packetWriter2.Write(qH.outSeqNum); packetWriter2.Write((int)qH.type); // packetWriter2.Write((int)qH.data); Event_Message eventMsg = new Event_Message((Event_Message)qH.data); packetWriter2.Write(eventMsg.GameID_A); // Debug.WriteLine("eventMsg " + eventMsg.GameID_A); packetWriter2.Write(eventMsg.GameID_B); // Debug.WriteLine("eventMsg " + eventMsg.GameID_B); packetWriter2.Write(eventMsg.collision_pt); // Debug.WriteLine("eventMsg " + eventMsg.collision_pt); if (Game1.networkSession != null) { if (Game1.networkSession.IsHost) { LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host; server.SendData(packetWriter2, SendDataOptions.InOrder); } } // Send our input data to the server. // gamer.SendData(packetWriter2, // SendDataOptions.InOrder, Game1.networkSession.Host); } //foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers) //{ // if (!Game1.networkSession.IsHost) // { // // Write our latest input state into a network packet. // packetWriter2.Write(qH.inSeqNum); // packetWriter2.Write(qH.outSeqNum); // packetWriter2.Write((int)qH.type); // // Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data; // // packetWriter2.Write(rotMessage.rotation); // // packetWriter2.Write((Vector2)qH.data); // // Send our input data to the server. // gamer.SendData(packetWriter2, // SendDataOptions.InOrder, Game1.networkSession.Host); // } //} break; default: break; } } }
static public void FSMTest() { System.Console.WriteLine("\n------------ FSM Phase 1: Explicit Calls ---------------\n"); FSM myFSM = new FSM(); myFSM.advance(0); //a myFSM.advance(1); //b myFSM.advance(0); //e myFSM.advance(1); //a myFSM.advance(1); //b myFSM.advance(0); //e myFSM.advance(0); //c myFSM.advance(1); //e myFSM.advance(1); //a myFSM.advance(1); //b myFSM.advance(1); //c myFSM.advance(0); //d myFSM.advance(0); //d myFSM.advance(1); //b myFSM.set(FSM_StateEnum.STATE_C); myFSM.advance(0); myFSM.advance(0); myFSM.advance(0); myFSM.set(FSM_StateEnum.STATE_C); myFSM.advance(1); myFSM.advance(0); myFSM.advance(0); myFSM.set(FSM_StateEnum.STATE_B); myFSM.advance(1); myFSM.advance(1); myFSM.advance(0); myFSM.set(FSM_StateEnum.STATE_D); myFSM.advance(1); myFSM.advance(0); myFSM.advance(1); System.Console.WriteLine("\n------------ FSM Phase 2: Data Driven ---------------\n"); FSM_Data myData; myData.input = 0; myData.state = FSM_StateEnum.STATE_A; myData.type = FSM_Type.FSM_ADV; //myFSM.advance(0); //a myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); //e myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(1); //a myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); //e myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(0); //c myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(1); //e myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(1); //a myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(1); //c myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); //d myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(0); //d myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.set(FSM_StateEnum.STATE_C); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_C; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.set(FSM_StateEnum.STATE_C); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_C; myFSM.doWork(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.set(FSM_StateEnum.STATE_B); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_B; myFSM.doWork(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.set(FSM_StateEnum.STATE_D); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_D; myFSM.doWork(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myFSM.doWork(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myFSM.doWork(myData); System.Console.WriteLine("\n------------ FSM Phase 3: Queued Data Driven ---------------\n"); System.Collections.Generic.Queue <FSM_Data> myQ_FSM = new System.Collections.Generic.Queue <FSM_Data>(); myData.input = 0; myData.state = FSM_StateEnum.STATE_A; myData.type = FSM_Type.FSM_ADV; //myFSM.advance(0); //a myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); //e myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //a myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); //e myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(0); //c myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //e myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //a myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //c myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); //d myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(0); //d myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(1); //b myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.set(FSM_StateEnum.STATE_C); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_C; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.set(FSM_StateEnum.STATE_C); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_C; myQ_FSM.Enqueue(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.set(FSM_StateEnum.STATE_B); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_B; myQ_FSM.Enqueue(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.set(FSM_StateEnum.STATE_D); myData.type = FSM_Type.FSM_SET; myData.state = FSM_StateEnum.STATE_D; myQ_FSM.Enqueue(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); //myFSM.advance(0); myData.type = FSM_Type.FSM_ADV; myData.input = 0; myQ_FSM.Enqueue(myData); //myFSM.advance(1); myData.type = FSM_Type.FSM_ADV; myData.input = 1; myQ_FSM.Enqueue(myData); // Now the queue is NOW filled // print the contents int count = myQ_FSM.Count; for (int i = 0; i < count; i++) { FSM_Data tmpData = myQ_FSM.Dequeue(); myFSM.doWork(tmpData); } }
static public void CalcTest() { Calc myCalc = new Calc(); System.Console.WriteLine("\n------------ Calc Phase 1: Explicit Calls ---------------\n"); myCalc.set(3); myCalc.add(2); myCalc.sub(8); myCalc.mult(2); myCalc.sub(5); myCalc.add(4); myCalc.add(22); myCalc.sub(4); myCalc.mult(2); myCalc.sub(5); myCalc.set(11); myCalc.add(2); myCalc.sub(7); myCalc.mult(3); myCalc.sub(5); System.Console.WriteLine("\n------------ Calc Phase 2: Data Driven ---------------\n"); Calc_Data data; // myCalc.set(3); data.type = Calc_Type.CALC_SET; data.value = 3; myCalc.doWork(data); // myCalc.add(2); data.type = Calc_Type.CALC_ADD; data.value = 2; myCalc.doWork(data); // myCalc.sub(8); data.type = Calc_Type.CALC_SUB; data.value = 8; myCalc.doWork(data); // myCalc.mult(2); data.type = Calc_Type.CALC_MULT; data.value = 2; myCalc.doWork(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myCalc.doWork(data); // myCalc.add(4); data.type = Calc_Type.CALC_ADD; data.value = 4; myCalc.doWork(data); // myCalc.add(22); data.type = Calc_Type.CALC_ADD; data.value = 22; myCalc.doWork(data); // myCalc.sub(4); data.type = Calc_Type.CALC_SUB; data.value = 4; myCalc.doWork(data); // myCalc.mult(2); data.type = Calc_Type.CALC_MULT; data.value = 2; myCalc.doWork(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myCalc.doWork(data); // myCalc.set(11); data.type = Calc_Type.CALC_SET; data.value = 11; myCalc.doWork(data); // myCalc.add(2); data.type = Calc_Type.CALC_ADD; data.value = 2; myCalc.doWork(data); // myCalc.sub(7); data.type = Calc_Type.CALC_SUB; data.value = 7; myCalc.doWork(data); // myCalc.mult(3); data.type = Calc_Type.CALC_MULT; data.value = 3; myCalc.doWork(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myCalc.doWork(data); System.Console.WriteLine("\n------------ Calc Phase 3: Queued Data Driven ---------------\n"); // Creates and initializes a new Queue. System.Collections.Generic.Queue <Calc_Data> myQ = new System.Collections.Generic.Queue <Calc_Data>(); // myCalc.set(3); data.type = Calc_Type.CALC_SET; data.value = 3; myQ.Enqueue(data); // myCalc.add(2); data.type = Calc_Type.CALC_ADD; data.value = 2; myQ.Enqueue(data); // myCalc.sub(8); data.type = Calc_Type.CALC_SUB; data.value = 8; myQ.Enqueue(data); // myCalc.mult(2); data.type = Calc_Type.CALC_MULT; data.value = 2; myQ.Enqueue(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myQ.Enqueue(data); // myCalc.add(4); data.type = Calc_Type.CALC_ADD; data.value = 4; myQ.Enqueue(data); // myCalc.add(22); data.type = Calc_Type.CALC_ADD; data.value = 22; myQ.Enqueue(data); // myCalc.sub(4); data.type = Calc_Type.CALC_SUB; data.value = 4; myQ.Enqueue(data); // myCalc.mult(2); data.type = Calc_Type.CALC_MULT; data.value = 2; myQ.Enqueue(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myQ.Enqueue(data); // myCalc.set(11); data.type = Calc_Type.CALC_SET; data.value = 11; myQ.Enqueue(data); // myCalc.add(2); data.type = Calc_Type.CALC_ADD; data.value = 2; myQ.Enqueue(data); // myCalc.sub(7); data.type = Calc_Type.CALC_SUB; data.value = 7; myQ.Enqueue(data); // myCalc.mult(3); data.type = Calc_Type.CALC_MULT; data.value = 3; myQ.Enqueue(data); // myCalc.sub(5); data.type = Calc_Type.CALC_SUB; data.value = 5; myQ.Enqueue(data); // Now the queue is NOW filled // print the contents int count = myQ.Count; for (int i = 0; i < count; i++) { Calc_Data tmpData = myQ.Dequeue(); myCalc.doWork(tmpData); } }
public override void Write(byte[] buffer, int offset, int count) { bool mustWait = false; // This method does this: // 0. handles any pending exceptions // 1. write any buffers that are ready to be written, // 2. fills a work buffer; when full, flip state to 'Filled', // 3. if more data to be written, goto step 1 if (_isClosed) { throw new InvalidOperationException(); } // dispense any exceptions that occurred on the BG threads if (_pendingException != null) { _handlingException = true; var pe = _pendingException; _pendingException = null; throw pe; } if (count == 0) { return; } if (!_firstWriteDone) { // Want to do this on first Write, first session, and not in the // constructor. We want to allow MaxBufferPairs to // change after construction, but before first Write. _InitializePoolOfWorkItems(); _firstWriteDone = true; } do { // may need to make buffers available EmitPendingBuffers(false, mustWait); mustWait = false; // use current buffer, or get a new buffer to fill int ix = -1; if (_currentlyFilling >= 0) { ix = _currentlyFilling; TraceOutput(TraceBits.WriteTake, "Write notake wi({0}) lf({1})", ix, _lastFilled); } else { TraceOutput(TraceBits.WriteTake, "Write take?"); if (_toFill.Count == 0) { // no available buffers, so... need to emit // compressed buffers. mustWait = true; continue; } ix = _toFill.Dequeue(); TraceOutput(TraceBits.WriteTake, "Write take wi({0}) lf({1})", ix, _lastFilled); ++_lastFilled; // TODO: consider rollover? } WorkItem workitem = _pool[ix]; int limit = ((workitem.buffer.Length - workitem.inputBytesAvailable) > count) ? count : (workitem.buffer.Length - workitem.inputBytesAvailable); workitem.ordinal = _lastFilled; TraceOutput(TraceBits.Write, "Write lock wi({0}) ord({1}) iba({2})", workitem.index, workitem.ordinal, workitem.inputBytesAvailable ); // copy from the provided buffer to our workitem, starting at // the tail end of whatever data we might have in there currently. Buffer.BlockCopy(buffer, offset, workitem.buffer, workitem.inputBytesAvailable, limit); count -= limit; offset += limit; workitem.inputBytesAvailable += limit; if (workitem.inputBytesAvailable == workitem.buffer.Length) { // No need for interlocked.increment: the Write() // method is documented as not multi-thread safe, so // we can assume Write() calls come in from only one // thread. TraceOutput(TraceBits.Write, "Write QUWI wi({0}) ord({1}) iba({2}) nf({3})", workitem.index, workitem.ordinal, workitem.inputBytesAvailable); #if !PCL if (!ThreadPool.QueueUserWorkItem(_DeflateOne, workitem)) { throw new Exception("Cannot enqueue workitem"); } #else System.Threading.Tasks.Task.Run(() => _DeflateOne(workitem)); #endif _currentlyFilling = -1; // will get a new buffer next time } else { _currentlyFilling = ix; } if (count > 0) { TraceOutput(TraceBits.WriteEnter, "Write more"); } }while (count > 0); // until no more to write TraceOutput(TraceBits.WriteEnter, "Write exit"); return; }