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);
}