public ExpressionParser(TokenStream stream) { tokenStream = stream; operatorStack = StackPool <OperatorNode> .Get(); expressionStack = StackPool <ASTNode> .Get(); }
IList <int> GetParentsBelowStackBased(int id) { Stack <int> stack = StackPool <int> .Get(); stack.Push(id); var parentsBelow = new List <int>(); while (stack.Count > 0) { int current = stack.Pop(); if (HasChildren(current)) { parentsBelow.Add(current); var children = GetChildren(current); foreach (var val in children) { stack.Push(val.Id); } ListPool <T> .Release(children); } } StackPool <int> .Release(stack); return(parentsBelow); }
public override QualifiedElement GetQualifiedName() { var accum = StackPool.Get(); try { foreach (var identity in From.Identities.Take(Order).Cast <IdentityElement>().Reverse()) { identity.AggregateIdentities(accum); } var ret = new QualifiedElement(); while (accum.Count != 0) { var(scope, category, name) = accum.Pop(); _ = new IdentityElement(ret, scope, category, name); } return(ret); } finally { Debug.Assert(accum.Count == 0); StackPool.Return(accum); } }
private ASTNode ParseInternal(string input) { tokenStream = new TokenStream(ExpressionTokenizer.Tokenize(input, StructList <ExpressionToken> .Get())); expressionStack = expressionStack ?? StackPool <ASTNode> .Get(); operatorStack = operatorStack ?? StackPool <OperatorNode> .Get(); if (tokenStream.Current == ExpressionTokenType.ExpressionOpen) { tokenStream.Advance(); } if (!tokenStream.HasMoreTokens) { throw new ParseException("Failed trying to parse empty expression"); } if (tokenStream.Last == ExpressionTokenType.ExpressionClose) { tokenStream.Chop(); } ASTNode retn = ParseLoop(); Release(); return(retn); }
public override QualifiedElement GetQualifiedName() { var stack = StackPool.Get(); try { foreach (var elem in AncestorsAndSelf()) { elem.AggregateIdentities(stack); } var ret = new QualifiedElement(); while (stack.Count != 0) { var(scope, category, name) = stack.Pop(); _ = new IdentityElement(ret, scope, category, name); } return(ret); } finally { Debug.Assert(stack.Count == 0); StackPool.Return(stack); } }
public static void TreeListChildren(TreeViewItem rootItem, IList <TreeViewItem> row) { row.Clear(); Stack <TreeViewItem> stack = StackPool <TreeViewItem> .Get(); for (int i = rootItem.children.Count - 1; i >= 0; i--) { stack.Push(rootItem.children[i]); } while (stack.Count > 0) { var item = stack.Pop(); row.Add(item); if (item.hasChildren && item.children[0] != null) { for (int i = item.children.Count - 1; i >= 0; i--) { stack.Push(item.children[i]); } } } StackPool <TreeViewItem> .Release(stack); }
string GetPath(GameObject gameObject) { Transform trans = gameObject.transform; Stack <Transform> stack = StackPool <Transform> .Get(); stack.Push(trans); while (trans.parent != null) { trans = trans.parent; stack.Push(trans); } string path = ""; while (stack.Count > 0) { var node = stack.Pop(); path += node.name; if (stack.Count > 0) { path += "/"; } } StackPool <Transform> .Release(stack); return(path); }
public TokenStream(StructList <ExpressionToken> tokens) { this.ptr = 0; this.tokens = tokens; this.lastTokenIndex = tokens.Count; this.stack = StackPool <int> .Get(); }
void Sort <T>(T rootItem, Comparison <TreeViewItem> func, Comparison <int> intfunc) where T : TreeViewItem { rootItem.children.Sort(func); Stack <TreeViewItem> itemstack = StackPool <TreeViewItem> .Get(); foreach (var child in rootItem.children) { itemstack.Push(child); } while (itemstack.Count > 0) { var item = itemstack.Pop(); if (_treeView.IsExpanded(item.id) && item.children.Count > 0 && item.children[0] != null) { foreach (var child in item.children) { itemstack.Push(child); } item.children.Sort(func); } } StackPool <TreeViewItem> .Release(itemstack); _model.Sort(intfunc); }
public static void ApplyActionLeafFirst(GraphData graph, Action <AbstractMaterialNode> action) { var temporaryMarks = PooledHashSet <string> .Get(); var permanentMarks = PooledHashSet <string> .Get(); var slots = ListPool <MaterialSlot> .Get(); // Make sure we process a node's children before the node itself. var stack = StackPool <AbstractMaterialNode> .Get(); foreach (var node in graph.GetNodes <AbstractMaterialNode>()) { stack.Push(node); } while (stack.Count > 0) { var node = stack.Pop(); if (permanentMarks.Contains(node.objectId)) { continue; } if (temporaryMarks.Contains(node.objectId)) { action.Invoke(node); permanentMarks.Add(node.objectId); } else { temporaryMarks.Add(node.objectId); stack.Push(node); node.GetInputSlots(slots); foreach (var inputSlot in slots) { var nodeEdges = graph.GetEdges(inputSlot.slotReference); foreach (var edge in nodeEdges) { var fromSocketRef = edge.outputSlot; var childNode = fromSocketRef.node; if (childNode != null) { stack.Push(childNode); } } } slots.Clear(); } } StackPool <AbstractMaterialNode> .Release(stack); ListPool <MaterialSlot> .Release(slots); temporaryMarks.Dispose(); permanentMarks.Dispose(); }
private StyleParser(StyleTokenStream stream) { tokenStream = stream; nodes = LightList <StyleASTNode> .Get(); operatorStack = StackPool <StyleOperatorNode> .Get(); expressionStack = StackPool <StyleASTNode> .Get(); groupExpressionStack = StackPool <AttributeNodeContainer> .Get(); groupOperatorStack = StackPool <StyleOperatorType> .Get(); }
void TryAddChildren(AssetTreeItem <T> rootitem, List <TreeViewItem> list, AssetTreeModel <T> model, int depth) { if (model.HasChildren(rootitem.DataId)) { List <T> children = model.GetChildren(rootitem.DataId); Stack <AssetTreeItem <T> > stack = StackPool <AssetTreeItem <T> > .Get(); for (int i = children.Count - 1; i >= 0; i--) { var child = children[i]; //create item var childItem = CreateItem(ref child, depth + 1); stack.Push(childItem); } ListPool <T> .Release(children); while (stack.Count > 0) { var stackChild = stack.Pop(); list.Add(stackChild); if (model.HasChildren(stackChild.DataId)) { if (IsExpanded(stackChild.id)) { children = model.GetChildren(stackChild.DataId); // //stackChild.children = new List<TreeViewItem>(); for (int i = children.Count - 1; i >= 0; i--) { var child = children[i]; //create item var childItem = CreateItem(ref child, stackChild.depth + 1); stack.Push(childItem); //stackChild.children.Add(childItem); } ListPool <T> .Release(children); } else { stackChild.children = CreateChildListForCollapsedParent(); } } } StackPool <AssetTreeItem <T> > .Release(stack); } }
void SearchItem(List <TreeViewItem> list, AssetTreeModel <T> model, int itemid) { if (list != null && model != null && model.HasChildren(itemid)) { List <T> children = model.GetChildren(itemid); Stack <T> stack = StackPool <T> .Get(); for (int i = children.Count - 1; i >= 0; i--) { stack.Push(children[i]); } ListPool <T> .Release(children); while (stack.Count > 0) { T current = stack.Pop(); if (!string.IsNullOrEmpty(current.DisplayName) && current.DisplayName.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0) { //Add result var viewitem = CreateItem(ref current, 0); list.Add(viewitem); } if (model.HasChildren(current.Id)) { children = model.GetChildren(current.Id); for (int i = children.Count - 1; i >= 0; i--) { stack.Push(children[i]); } ListPool <T> .Release(children); } } StackPool <T> .Release(stack); } }
public override QualifiedElement GetQualifiedName() { var accum = StackPool.Get(); try { AggregateIdentities(accum); var piv = Parent switch { NameSpaceElement ns => ns.Parent, _ => Parent }; if (!(piv is ImaginaryRoot)) { foreach (var element in piv.AncestorsAndSelf()) { element.AggregateIdentities(accum); } } var ret = new QualifiedElement(); while (accum.Count != 0) { var(scope, cat, nme) = accum.Pop(); _ = new IdentityElement(ret, scope, cat, nme); } return(ret); } finally { Debug.Assert(accum.Count == 0); StackPool.Return(accum); } }
void AddPathRecursive(HashSet <string> hashset, string path) { if (path != Application.dataPath) { path = path.Replace('\\', '/'); string subpath = path; Stack <string> stack = StackPool <string> .Get(); while (true) { int index = subpath.LastIndexOf('/'); if (index >= 0) { subpath = path.Substring(0, index); stack.Push(subpath); } else { subpath = null; } if (string.IsNullOrEmpty(subpath) || subpath == Application.dataPath) { break; } } while (stack.Count > 0) { string result = stack.Pop(); hashset.Add(result); } StackPool <string> .Release(stack); } }
IEnumerator ParseAssetBundle(AssetTreeModel <AssetTreeData> dataModel, Dictionary <string, string[]> assetbundleDictionary, int total) { //create root AssetTreeData rootData = new AssetTreeData(); rootData.Id = AssetTreeManager.mIns.GetUniqueId(); dataModel.Root = rootData; dataModel.Add(ref rootData); //Editor Ui int progress = 0; float totalprogress = total + 2; yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Start Parseing", 0f)); foreach (var assetbundleinfo in assetbundleDictionary) { var assetbundlename = assetbundleinfo.Key; var assetpaths = assetbundleinfo.Value; if (assetpaths.Length > 0) { AssetTreeData folderData = CreateBaseAssetBundle(assetpaths, assetbundlename, dataModel); folderData.IsAssetBundleViewData = true; foreach (var assetpath in assetpaths) { CreateSubAssetBundle(dataModel, folderData.Id, assetpath, assetbundlename); //Editor Ui progress++; if (progress % AssetWindowConfig.ParseStep == 0) { yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Parseing " + assetpath, progress / totalprogress)); } } } } yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Set Dependency", (progress + 1) / totalprogress)); List <AssetTreeData> nonamelist = new List <AssetTreeData>(); Stack <AssetTreeData> itemStack = StackPool <AssetTreeData> .Get(); var allTreeDatas = dataModel.GetAllItems(); //set dependency references for (int i = 0; i < allTreeDatas.Count; i++) { var info = allTreeDatas[i]; itemStack.Push(info); //SetAssetDependRef(ref info,dataModel,nonamelist); } ListPool <AssetTreeData> .Release(allTreeDatas); yield return(SetAssetDependRef(itemStack, dataModel, nonamelist)); StackPool <AssetTreeData> .Release(itemStack); yield return(DisplayProgressBar("Asset-Parse AssetBundle", "Assigning NoAssetName", 1f)); for (int i = 0; i < nonamelist.Count; i++) { var nonameitem = nonamelist[i]; var deplist = dataModel.GetDependParents(nonameitem.FilePath); for (int j = 0; j < deplist.Count; j++) { var dep = deplist[j]; if (j == 0) { dataModel.AddChild(dep.Id, nonameitem.Id); } else { nonameitem.Id = AssetTreeManager.mIns.GetUniqueId(); dataModel.Add(ref nonameitem); //dataModel.AddViewData(ref nonameitem); dataModel.AddChild(dep.Id, nonameitem.Id); } } } yield return(null); EditorUtility.ClearProgressBar(); }
protected override void SelectionChanged(IList <int> selectedIds) { if (selectedIds.Count > 0) { FrameItem(selectedIds[0]); var render = AssetTreeManager.mIns.GetGuiRender(EditorContexts.mIns.Mode); if (render != null) { List <TreeViewItem> itemList = ListPool <TreeViewItem> .Get(); var rows = GetRows(); for (int i = 0; i < rows.Count; i++) { var rowdata = rows[i] as AssetTreeItem <T>; if (rowdata != null && selectedIds.Contains(rowdata.id)) { itemList.Add(rowdata); } } foreach (var subrender in render) { if (subrender.TypeMode == _viewMode) { IGuiTree treeRender = subrender as IGuiTree; if (treeRender != null) { treeRender.SelectionChanged(itemList); } } } //is searching if (!string.IsNullOrEmpty(searchString)) { IList <int> expandlist = GetExpanded(); if (expandlist != null) { List <int> list = new List <int>(); list.AddRange(expandlist); Stack <int> stack = StackPool <int> .Get(); foreach (var item in itemList) { stack.Push(item.id); } while (stack.Count > 0) { var itemid = stack.Pop(); if (!list.Contains(itemid)) { list.Add(itemid); if (_model.HasParent(itemid)) { var parents = _model.GetParent(itemid); foreach (var parent in parents) { if (!list.Contains(parent.Id) && parent.Id != _model.Root.Id) { stack.Push(parent.Id); } } ListPool <T> .Release(parents); } } } StackPool <int> .Release(stack); SetExpanded(list); } } ListPool <TreeViewItem> .Release(itemList); } else { base.SelectionChanged(selectedIds); } } }
public StyleTokenStream(List <StyleToken> tokens) { ptr = 0; this.tokens = tokens; stack = StackPool <int> .Get(); }
public void RefreshUI() { trdLst.Clear(); List <TaskRewardData> finishedLst = new List <TaskRewardData>(); List <TaskRewardData> todoLst = new List <TaskRewardData>(); List <TaskRewardData> doneLst = new List <TaskRewardData>(); //1|0|0 for (int i = 0; i < pd.taskArr.Length; i++) { string[] taskInfo = pd.taskArr[i].Trim().Split('|'); TaskRewardData trd = new TaskRewardData { ID = int.Parse(taskInfo[0]), prgs = int.Parse(taskInfo[1]), taked = taskInfo[2].Equals("1"), }; TaskRewardCfg trc = resSvc.GetTaskRewardCfg(trd.ID); if (trd.prgs == trc.count && !trd.taked) { finishedLst.Add(trd); } else if (trd.taked) { doneLst.Add(trd); } else { todoLst.Add(trd); } } trdLst.AddRange(finishedLst); trdLst.AddRange(todoLst); trdLst.AddRange(doneLst); //Item push into pool while (ScrollTrans.childCount > 0) { GameObject go = ScrollTrans.GetChild(ScrollTrans.childCount - 1).gameObject; go.SetActive(false); go.transform.SetParent(PoolParent); StackPool.Add(go); } //fill the task list for (int i = 0; i < trdLst.Count; i++) { //GameObject go = resSvc.LoadPrefab(PathDefine.TaskItemPrefab); GameObject go = StackPool.Get(); go.transform.SetParent(ScrollTrans); go.transform.localPosition = Vector3.zero; go.transform.localScale = Vector3.one; go.name = "taskItem_" + i; TaskRewardData trd = trdLst[i]; TaskRewardCfg trf = resSvc.GetTaskRewardCfg(trd.ID); SetText(GetTrans(go.transform, "txtName"), trf.taskName); SetText(GetTrans(go.transform, "txtPrg"), trd.prgs + "/" + trf.count); SetText(GetTrans(go.transform, "txtExp"), "奖励: 经验" + trf.exp); SetText(GetTrans(go.transform, "txtCoin"), "金币" + trf.coin); Image imgPrg = GetTrans(go.transform, "prgBar/prgVal").GetComponent <Image>(); float prgVal = trd.prgs * 1.0f / trf.count; imgPrg.fillAmount = prgVal; Button btnTake = GetTrans(go.transform, "btnTake").GetComponent <Button>(); btnTake.onClick.RemoveAllListeners(); btnTake.onClick.AddListener(() => { ClickTakeBtn(go.name); }); Transform transComp = GetTrans(go.transform, "imgComp"); if (trd.taked) { btnTake.interactable = false; SetActive(transComp); } else { SetActive(transComp, false); if (trd.prgs == trf.count) { btnTake.interactable = true; } else { btnTake.interactable = false; } } go.SetActive(true); } }
public void ValidateGraph() { var propertyNodes = GetNodes <PropertyNode>().Where(n => !m_Properties.Any(p => p.guid == n.propertyGuid)).ToArray(); foreach (var pNode in propertyNodes) { ReplacePropertyNodeWithConcreteNodeNoValidate(pNode); } messageManager?.ClearAllFromProvider(this); //First validate edges, remove any //orphans. This can happen if a user //manually modifies serialized data //of if they delete a node in the inspector //debug view. foreach (var edge in edges.ToArray()) { var outputNode = GetNodeFromGuid(edge.outputSlot.nodeGuid); var inputNode = GetNodeFromGuid(edge.inputSlot.nodeGuid); MaterialSlot outputSlot = null; MaterialSlot inputSlot = null; if (outputNode != null && inputNode != null) { outputSlot = outputNode.FindOutputSlot <MaterialSlot>(edge.outputSlot.slotId); inputSlot = inputNode.FindInputSlot <MaterialSlot>(edge.inputSlot.slotId); } if (outputNode == null || inputNode == null || outputSlot == null || inputSlot == null || !outputSlot.IsCompatibleWith(inputSlot)) { //orphaned edge RemoveEdgeNoValidate(edge); } } var temporaryMarks = IndexSetPool.Get(); var permanentMarks = IndexSetPool.Get(); var slots = ListPool <MaterialSlot> .Get(); // Make sure we process a node's children before the node itself. var stack = StackPool <AbstractMaterialNode> .Get(); foreach (var node in GetNodes <AbstractMaterialNode>()) { stack.Push(node); } while (stack.Count > 0) { var node = stack.Pop(); if (permanentMarks.Contains(node.tempId.index)) { continue; } if (temporaryMarks.Contains(node.tempId.index)) { node.ValidateNode(); permanentMarks.Add(node.tempId.index); } else { temporaryMarks.Add(node.tempId.index); stack.Push(node); node.GetInputSlots(slots); foreach (var inputSlot in slots) { var nodeEdges = GetEdges(inputSlot.slotReference); foreach (var edge in nodeEdges) { var fromSocketRef = edge.outputSlot; var childNode = GetNodeFromGuid(fromSocketRef.nodeGuid); if (childNode != null) { stack.Push(childNode); } } } slots.Clear(); } } StackPool <AbstractMaterialNode> .Release(stack); ListPool <MaterialSlot> .Release(slots); IndexSetPool.Release(temporaryMarks); IndexSetPool.Release(permanentMarks); foreach (var edge in m_AddedEdges.ToList()) { if (!ContainsNodeGuid(edge.outputSlot.nodeGuid) || !ContainsNodeGuid(edge.inputSlot.nodeGuid)) { Debug.LogWarningFormat("Added edge is invalid: {0} -> {1}\n{2}", edge.outputSlot.nodeGuid, edge.inputSlot.nodeGuid, Environment.StackTrace); m_AddedEdges.Remove(edge); } } foreach (var groupChange in m_NodeGroupChanges.ToList()) { if (!ContainsNodeGuid(groupChange.nodeGuid)) { m_NodeGroupChanges.Remove(groupChange); } } }
protected override TreeViewItem BuildRoot() { Stack <ElementTreeItem> stack = StackPool <ElementTreeItem> .Get(); // todo -- maybe pool tree items TreeViewItem root = new TreeViewItem(-9999, -1); foreach (UIView uiView in views) { if (uiView.RootElement == null) { continue; } if (uiView.RootElement.isDisabled && !showDisabled) { continue; } ElementTreeItem firstChild = new ElementTreeItem(uiView.RootElement); firstChild.displayName = uiView.RootElement.ToString(); stack.Push(firstChild); while (stack.Count > 0) { ElementTreeItem current = stack.Pop(); if (current.element.isDisabled && !showDisabled) { continue; } UIElement element = current.element; List <UIElement> ownChildren = element.GetChildren(); if (ownChildren.Count == 0) { ListPool <UIElement> .Release(ref ownChildren); continue; } for (int i = 0; i < ownChildren.Count; i++) { ElementTreeItem childItem = new ElementTreeItem(ownChildren[i]); if (childItem.element.isDisabled && !showDisabled) { continue; } childItem.displayName = ownChildren[i].ToString(); current.AddChild(childItem); stack.Push(childItem); } } root.AddChild(firstChild); } root.displayName = "ROOT"; SetupDepthsFromParentsAndChildren(root); needsReload = false; if (root.children == null) { root.children = new List <TreeViewItem>(); } return(root); }