public void AddBinary(ExpressionType nodeType) { if (Current != null) _stack.Push( Current ); Current = new BinaryNode( nodeType ); }
public static void CreateTree() { m_Tree = new BinaryNode(); int nrBits = 0, val = 0; BinaryNode current = m_Tree; for(int i = 0; i < 257; i++) // was 257 { current = m_Tree; nrBits = (int)bit_table[i,0] - 1; val = (int)bit_table[i,1]; for(int n = nrBits; n >= 0; n--) { if((val >> n) % 2 == 1) { if(current.Left == null) current.Left = new BinaryNode(); current = current.Left; } else { if(current.Right == null) current.Right = new BinaryNode(); current = current.Right; } } current.IsLeaf = true; current.Value = i; } }
private void _addChildrenAvoidEndpoinDoubleAdding(ref Stack<BinaryNode> traverseStack, BinaryNode node) { if (node.RightChild != null) traverseStack.Push(node.RightChild); if (node.LeftChild != null) { if (node.LeftChild.Type != NodeType.ConditionEndPoint) traverseStack.Push(node.LeftChild); if (_conditionEndPointRightBranchChild(node)) traverseStack.Push(node.LeftChild); } }
public void CompleteBinary( ) { if (!_stack.Any()) return; BinaryNode node = _stack.Pop(); if (node.Left == null) node.Left = Current; else node.Right = Current; Current = node; }
static BinaryNode<int> GetSampleTree() { int[] content = { 5, 3, 7, 2, 4, 6, 8 }; BinaryNode<int> root = new BinaryNode<int>(content[0]); for (int i = 1; i < content.Length; i++) { root.Add(content[i]); } return root; }
public BinaryNode(int[,] value, int row, int col) { var maxRow = value.GetUpperBound(0); var maxCol = value.GetUpperBound(1); Value = value[row, col]; if(row + 1 <= maxRow) { Left = new BinaryNode(value, row +1, col); if(col +1 <= maxCol) { Right = new BinaryNode(value, row + 1, col + 1); } } }
public void Execute(TypeModel model, string caption) { BinaryNode head = new BinaryNode(); BinaryNode node = head; // 13 is the magic limit that triggers recursion check for (int i = 0; i < 13; ++i) { node.Left = new BinaryNode(); node = (BinaryNode)node.Left; } var clone = (Node)model.DeepClone(head); Assert.AreEqual(head.Count(), clone.Count(), caption); }
/// <summary> /// Create a balanced binary search tree with n nodes /// </summary> static BinaryNode<int> GetBalancedTree(int n) { List<int> list = new List<int>(n); for (int i = 1; i <= n; i++) list.Add(i); List<int> balancedList = GetBalancedList(list); BinaryNode<int> root = new BinaryNode<int>(balancedList[0]); for (int i = 1; i < balancedList.Count; i++) { root.Add(balancedList[i]); } return root; }
public void AddNode_AddEightRandomNumbers_OrderIsSorted() { BinaryNode<int> root = new BinaryNode<int>(4); List<int> expected = new List<int>() { 4 }; Random rand = new Random(); for (int i = 0; i < 8; i++) { int x = rand.Next(0, 100); root.AddNode(x); expected.Add(x); } root.TraverseInorder(); expected.Sort(); Assert.AreEqual(expected, root.TreeListing); }
public void InorderTraversal_SetsTreelisting() { BinaryNode<int> root = new BinaryNode<int>(4); BinaryNode<int> node1 = new BinaryNode<int>(1); BinaryNode<int> node2 = new BinaryNode<int>(2); BinaryNode<int> node3 = new BinaryNode<int>(3); BinaryNode<int> node5 = new BinaryNode<int>(5); BinaryNode<int> node6 = new BinaryNode<int>(6); BinaryNode<int> node7 = new BinaryNode<int>(7); BinaryNode<int> node8 = new BinaryNode<int>(8); root.LeftChild = node2; root.RightChild = node5; node2.LeftChild = node1; node2.RightChild = node3; node5.RightChild = node7; node7.LeftChild = node6; node7.RightChild = node8; root.TraverseInorder(); List<int> expected = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 }; Assert.AreEqual(expected, root.TreeListing); }
public void InorderTraversal_PrintsList() { BinaryNode<int> root = new BinaryNode<int>(4); BinaryNode<int> node1 = new BinaryNode<int>(1); BinaryNode<int> node2 = new BinaryNode<int>(2); BinaryNode<int> node3 = new BinaryNode<int>(3); BinaryNode<int> node5 = new BinaryNode<int>(5); BinaryNode<int> node6 = new BinaryNode<int>(6); BinaryNode<int> node7 = new BinaryNode<int>(7); BinaryNode<int> node8 = new BinaryNode<int>(8); root.LeftChild = node2; root.RightChild = node5; node2.LeftChild = node1; node2.RightChild = node3; node5.RightChild = node7; node7.LeftChild = node6; node7.RightChild = node8; root.TraverseInorderRecursively(); List<int> expected = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 }; List<int> dummy = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 }; Assert.AreEqual(expected, dummy); }
public void SetRight(BinaryNode <T> right) { _right = right; }
public BinaryNode(T item) { _item = item; _left = null; _right = null; }
public BinaryOrNode(BinaryNode parent, BinaryNode left, BinaryNode right) : base(parent, left, right) { }
private IQueryNode CreateNode(Expression path, JProperty property) { if (property.Name[0] == '$' && property.Name != "$size") { // Special functions. if (property.Name == "$or") { var array = (JArray)property.Value; return(new OrNode(array.Values <JObject>().Select(o => Parse(path, o)))); } if (property.Name == "$nor") { var array = (JArray)property.Value; return(new NorNode(array.Values <JObject>().Select(o => Parse(path, o)))); } if (property.Name == "$not") { return(new NotNode(Parse(path, (JObject)property.Value))); } if (property.Name == "$in") { var array = (JArray)property.Value; return(new InNode(path, array)); } if (property.Name == "$elemMatch") { var parser = new QueryParser(GetEnumerableType(path), _typeDescriptorFactory); var parsedElement = parser.GetType() .GetMethod("ParseWhere") .Invoke(parser, new object[] { property.Value }) as Expression; return(new ElementMatchNode(path, parsedElement)); } if (property.Name == "$nin") { var array = (JArray)property.Value; return(new NotNode(new InNode(path, array))); } if (BinaryNode.Arguments.ContainsKey(property.Name)) { return(new BinaryNode(path, property)); } throw new NotSupportedException(string.Format("{0} Does not support parsing element type {1}", GetType(), property.Name)); } Expression left = property.Name == "$size" ? SizeNode.GetExpression(_argument, path) : _typeDescriptorFactory.Create(path.Type).GetStateProperty(property.Name).CreateGetExpression(path); if (property.HasValues && property.Value is JObject) { // Composite object IEnumerable <IQueryNode> innerNodes = property.Values <JObject>().Select(o => Parse(left, o)); if (left.Type.IsClass) { // Check nullability. var extraNode = new BinaryNode(left, new JProperty("$ne", null)); innerNodes = new[] { extraNode }.Concat(innerNodes); } return(new AndNode(innerNodes)); } return(new EqualQueryNode(left, ((JValue)property.Value).Value)); }
private ExpressionNode ParseBrackets() { var ret = ParseAtom(); while (Accept(TokenType.LBRACK, TokenType.PERIOD, TokenType.LPAREN)) { var zero = new IntNode(Position(), 0); var length = new BinaryNode(Position(), BinaryOP.SUB, new UnaryNode(Position(), UnaryOP.LENGTH, ret), new IntNode(Position(), 1)); var pos = Position(); if (Accept(TokenType.LBRACK)) { Next(); if (Accept(TokenType.COLON)) { Next(); if (Accept(TokenType.RBRACK)) { Next(); ret = new SliceNode(pos, ret, zero, length); } else { var end = ParseExpression(); Expect(TokenType.RBRACK); Next(); ret = new SliceNode(pos, ret, zero, end); } } else { var start = ParseExpression(); if (Accept(TokenType.COLON)) { Next(); if (Accept(TokenType.RBRACK)) { Next(); ret = new SliceNode(pos, ret, start, length); } else { var end = ParseExpression(); Expect(TokenType.RBRACK); Next(); ret = new SliceNode(pos, ret, start, end); } } else { Expect(TokenType.RBRACK); Next(); ret = new IndexNode(pos, ret, start); } } } else if (Accept(TokenType.PERIOD)) { Next(); ret = new IndexNode(Position(-1), ret, new StringNode(Position(), ParseIdent().Value)); } else if (Accept(TokenType.LPAREN)) { Next(); var call = new CallNode(pos, ret); while (More() && !Accept(TokenType.RPAREN)) { call.Arguments.Add(ParseExpression()); if (Accept(TokenType.COMMA)) { ExpectNot(TokenType.RPAREN); Next(); } else { Expect(TokenType.RPAREN); } } Expect(TokenType.RPAREN); Next(); ret = call; } else { Unexpected(); } } return(ret); }
public void VisitBinary(BinaryNode node) { UpdateLine(node); if (node.OP == BinaryOP.AND) { node.Left.Accept(this); var f = asm.NewLabel(); asm.Not(); asm.Branch(f); node.Right.Accept(this); asm.Not(); asm.Branch(f); asm.PushTrue(); var end = asm.NewLabel(); asm.Jump(end); asm.MarkLabel(f); asm.PushFalse(); asm.MarkLabel(end); } else if (node.OP == BinaryOP.OR) { node.Left.Accept(this); var t = asm.NewLabel(); asm.Branch(t); node.Right.Accept(this); asm.Branch(t); asm.PushFalse(); var end = asm.NewLabel(); asm.Jump(end); asm.MarkLabel(t); asm.PushTrue(); asm.MarkLabel(end); } else { node.Left.Accept(this); node.Right.Accept(this); switch (node.OP) { case BinaryOP.ADD: asm.Add(); break; case BinaryOP.SUB: asm.Sub(); break; case BinaryOP.MUL: asm.Mul(); break; case BinaryOP.DIV: asm.Div(); break; case BinaryOP.POW: asm.Pow(); break; case BinaryOP.MOD: asm.Mod(); break; case BinaryOP.LSH: asm.Lsh(); break; case BinaryOP.RSH: asm.Rsh(); break; case BinaryOP.BIT_NOT: asm.BitNot(); break; case BinaryOP.BIT_AND: asm.BitAnd(); break; case BinaryOP.BIT_OR: asm.BitOr(); break; case BinaryOP.BIT_XOR: asm.BitXor(); break; case BinaryOP.CONCAT: asm.Concat(); break; case BinaryOP.EQ: asm.Eq(); break; case BinaryOP.NE: asm.Ne(); break; case BinaryOP.DEEP_EQ: asm.DeepEq(); break; case BinaryOP.DEEP_NE: asm.DeepNe(); break; case BinaryOP.LT: asm.Lt(); break; case BinaryOP.GT: asm.Gt(); break; case BinaryOP.LTE: asm.Lte(); break; case BinaryOP.GTE: asm.Gte(); break; default: throw new Exception(node.OP.ToString()); } } }
//assume distinct values public int largestBSTSize(BinaryNode root) { return(largestBST(root).sizeAny); }
//---------------------------------------------------------------------- // Interface methods that have to be implemented for exam //---------------------------------------------------------------------- public void Insert(T x) { BinaryNode <T> node = Insert(this.root, x); this.root = node; }
public static int GetHeight(BinaryNode <T> root) { var height = new Height(); return(GetBinaryTreeDiameter(root, height)); }
public static BinaryNode CreateBinaryNode(int topCustomerID, int customerID, int parentID, int placement, int level, int indentedSort) { BinaryNode binaryNode = new BinaryNode(); binaryNode.TopCustomerID = topCustomerID; binaryNode.CustomerID = customerID; binaryNode.ParentID = parentID; binaryNode.Placement = placement; binaryNode.Level = level; binaryNode.IndentedSort = indentedSort; return binaryNode; }
public void AddToBinaryTree(BinaryNode binaryNode) { base.AddObject("BinaryTree", binaryNode); }
public BinaryOrNode(BinaryNode left, BinaryNode right) : base(left, right) { }
public virtual void VisitBinaryNode(BinaryNode binop) { }
/// <summary> /// Determine if contains keyword and if it's possible to convert non-keyword types to keyword type /// ie. monday = 4 or month in (may,...,december) /// </summary> /// <param name="node">Node do check.</param> /// <returns>true if can be generalized, else false.</returns> private static bool CanBeGeneralized(BinaryNode node) => CanBeGeneralized(node.Left, node.Right);
public void BuildJoin(BinaryNode node) { BuildJoin((dynamic)node.Left, (dynamic)node.Right, node.Operator); }
public StateType adjustAgentStateTypeForBinaryNode(BinaryNode node, int playerNumber) { StateType nodeStateType = (StateType)node.getBinary(); if (playerNumber == 1) { if (node.hasFlag(StateType.ST_Agent1)) { nodeStateType = nodeStateType & (~StateType.ST_Agent1); nodeStateType = nodeStateType | StateType.ST_Agent; } if (node.hasSomeFlag(StateType.ST_Agent2 | StateType.ST_Agent3 | StateType.ST_Agent4)) { nodeStateType = nodeStateType & (~StateType.ST_Agent2); nodeStateType = nodeStateType & (~StateType.ST_Agent3); nodeStateType = nodeStateType & (~StateType.ST_Agent4); nodeStateType = nodeStateType | StateType.ST_EnemyAgent; } } else if (playerNumber == 2) { if (node.hasFlag(StateType.ST_Agent2)) { nodeStateType = nodeStateType & (~StateType.ST_Agent2); nodeStateType = nodeStateType | StateType.ST_Agent; } if (node.hasSomeFlag(StateType.ST_Agent1 | StateType.ST_Agent3 | StateType.ST_Agent4)) { nodeStateType = nodeStateType & (~StateType.ST_Agent1); nodeStateType = nodeStateType & (~StateType.ST_Agent3); nodeStateType = nodeStateType & (~StateType.ST_Agent4); nodeStateType = nodeStateType | StateType.ST_EnemyAgent; } } else if (playerNumber == 3) { if (node.hasFlag(StateType.ST_Agent3)) { nodeStateType = nodeStateType & (~StateType.ST_Agent3); nodeStateType = nodeStateType | StateType.ST_Agent; } if (node.hasSomeFlag(StateType.ST_Agent1 | StateType.ST_Agent2 | StateType.ST_Agent4)) { nodeStateType = nodeStateType & (~StateType.ST_Agent1); nodeStateType = nodeStateType & (~StateType.ST_Agent2); nodeStateType = nodeStateType & (~StateType.ST_Agent4); nodeStateType = nodeStateType | StateType.ST_EnemyAgent; } } else if (playerNumber == 4) { if (node.hasFlag(StateType.ST_Agent4)) { nodeStateType = nodeStateType & (~StateType.ST_Agent4); nodeStateType = nodeStateType | StateType.ST_Agent; } if (node.hasSomeFlag(StateType.ST_Agent1 | StateType.ST_Agent2 | StateType.ST_Agent3)) { nodeStateType = nodeStateType & (~StateType.ST_Agent1); nodeStateType = nodeStateType & (~StateType.ST_Agent2); nodeStateType = nodeStateType & (~StateType.ST_Agent3); nodeStateType = nodeStateType | StateType.ST_EnemyAgent; } } return(nodeStateType); }
private string InOrder(BinaryNode <T> node) { return((node.left != null ? InOrder(node.left) + " " : "") + node.data + (node.right != null ? " " + InOrder(node.right) : "")); }
public virtual void VisitBinaryNode(BinaryNode binop) { binop.Left.Visit(this); binop.Right.Visit(this); }
private static bool IsTripletPresentWithZeroSum(BinaryNode node) { return(false); }
internal BinaryEnumerator(BinarySearchTree <T> tree) { _tree = tree; _currentNode = null; _leftNode = _rightNode = _tree._root; }
private Info largestBST(BinaryNode root) { Info info = new Info { sizeRooted = 0, sizeAny = 0, isBST = false }; if (root == null) { return(info); } if (root.left == null && root.right == null) { info.isBST = true; info.sizeRooted = 1; info.sizeAny = 1; info.minIfBst = root.value; info.maxIfBst = root.value; return(info); } Info leftSide = largestBST(root.left), rightSide = largestBST(root.right); if (root.left != null && root.right == null) { if (leftSide.isBST && leftSide.maxIfBst < root.value) { info.isBST = true; info.sizeRooted = 1 + leftSide.sizeRooted; info.sizeAny = 1 + leftSide.sizeAny; info.minIfBst = Math.Min(leftSide.minIfBst, root.value); info.maxIfBst = Math.Max(leftSide.maxIfBst, root.value); } else { info.sizeAny = leftSide.sizeAny; } } else if (root.left == null && root.right != null) { if (rightSide.isBST && rightSide.minIfBst > root.value) { info.isBST = true; info.sizeRooted = 1 + rightSide.sizeRooted; info.sizeAny = 1 + rightSide.sizeAny; info.minIfBst = Math.Min(rightSide.minIfBst, root.value); info.maxIfBst = Math.Max(rightSide.maxIfBst, root.value); } else { info.sizeAny = rightSide.sizeAny; } } else { if (leftSide.isBST && rightSide.isBST && leftSide.maxIfBst < root.value && rightSide.minIfBst > root.value) { info.isBST = true; info.sizeRooted = 1 + leftSide.sizeRooted + rightSide.sizeRooted; info.sizeAny = 1 + leftSide.sizeAny + rightSide.sizeAny; info.minIfBst = Math.Min(leftSide.minIfBst, root.value); info.minIfBst = Math.Min(rightSide.minIfBst, info.minIfBst); info.maxIfBst = Math.Max(leftSide.maxIfBst, root.value); info.maxIfBst = Math.Max(rightSide.maxIfBst, info.maxIfBst); } else { info.sizeAny = Math.Max(rightSide.sizeAny, leftSide.sizeAny); } } return(info); }
/// <summary> /// Устанавливает перечислитель в его начальное положение, т. е. перед первым элементом односвязного списка. /// </summary> public void Reset() { _currentNode = null; _leftNode = _rightNode = _tree._root; }
public static void Print(this BinaryNode root, int topMargin = 2, int leftMargin = 2) { if (root == null) { return; } int rootTop = Console.CursorTop + topMargin; var last = new List <NodeInfo>(); var next = root; for (int level = 0; next != null; level++) { var item = new NodeInfo { Node = next, Text = next.Item.ToString(" 0 ") }; if (level < last.Count) { item.StartPos = last[level].EndPos + 1; last[level] = item; } else { item.StartPos = leftMargin; last.Add(item); } if (level > 0) { item.Parent = last[level - 1]; if (next == item.Parent.Node.Left) { item.Parent.Left = item; item.EndPos = Math.Max(item.EndPos, item.Parent.StartPos); } else { item.Parent.Right = item; item.StartPos = Math.Max(item.StartPos, item.Parent.EndPos); } } next = next.Left ?? next.Right; for (; next == null; item = item.Parent) { Print(item, rootTop + 2 * level); if (--level < 0) { break; } if (item == item.Parent.Left) { item.Parent.StartPos = item.EndPos; next = item.Parent.Node.Right; } else { if (item.Parent.Left == null) { item.Parent.EndPos = item.StartPos; } else { item.Parent.StartPos += (item.StartPos - item.Parent.EndPos) / 2; } } } } Console.SetCursorPosition(0, rootTop + 2 * last.Count - 1); }
/// <summary> /// Освобождает все ресурсы, занятые модулем <see cref="BinaryEnumerator"/>. /// </summary> public void Dispose() { _tree = null; _currentNode = _leftNode = _rightNode = null; }
private ExpressionNode ParseInterpolatedString() { Expect(TokenType.INTERPOLATED_STRING); var pos = Position(); var str = Current().Text; Next(); var parts = new List <ExpressionNode>(); bool inExpr = false; int level = 0; var start = 0; int i = 0; char peek() => str[i]; string current() => str.Substring(start, i - start - 1); bool accept(char c) { if (peek() == c) { i++; return(true); } return(false); } void addString() { var cur = current(); parts.Add(new StringNode(new SourcePosition(pos.Line, pos.Column + i - cur.Length + 1), cur)); } void addExpression() { var cur = current(); var lexer = new Lexer.Lexer(cur, new SourcePosition(pos.Line - 1, 0 /* @TODO wrong column number */)); var parser = new Parser("<interpolated string expression>", lexer.Tokenize()); parts.Add(parser.ParseExpression()); } while (i < str.Length) { if (inExpr) { if (accept('{')) { level++; } else if (accept('}')) { level--; } if (level == 0) { addExpression(); inExpr = false; start = i; } else { i++; } } else { if (accept('{')) { addString(); inExpr = true; level = 1; start = i; } else { i++; } } } if (inExpr) { throw new ParseException("String interpolation expression not ended"); } if (start != i) { i++; addString(); } if (parts.Count == 1) { return(parts[0]); } else { var ret = new BinaryNode(pos /* @TODO: wrong column number */, BinaryOP.CONCAT, parts[0], parts[1]); for (var j = 2; j < parts.Count; j++) { ret = new BinaryNode(pos /* @TODO: wrong column number */, BinaryOP.CONCAT, ret, parts[j]); } return(ret); } }
public void RemoveNode(PathNode pathNode) { if (root.pathNode == pathNode) { // It's the root //debugCodePath += "RR" + root + "; "; BinaryNode prevRoot = root; if (root.left == null && root.right == null) { // Both are null root = null; // Tree is dead } else { // Atleast one has something if (root.left == null && root.right != null) { // Has right but no left root = root.right; } else { if (root.right == null && root.left != null) { // Has left but no right root = root.left; } else { // Has both right and left if (root.left.right == null) { // Root left has no right root.left.right = root.right; root = root.left; } else { // Root left has a right BinaryNode leafRight = getLeafRight(root.left); root = leafRight.right; if (leafRight.right.left != null) { // This leaf has a left leafRight.right = leafRight.right.left; } leafRight.right = null; root.left = leafRight; root.right = prevRoot.right; } } } } } else { int pathFvalue = pathNode.fValue; removeNode(root, pathNode, pathFvalue); } totalNodes--; }
private void removeNode(BinaryNode node, PathNode pathNode, int pathFvalue) { if (pathFvalue <= node.pathNode.fValue) { // Check left // Is it this left? if (node.left != null) { if (node.left.pathNode == pathNode) { // It's this left one! BinaryNode del = node.left; //debugCodePath += "RNL" + del + "; "; if (del.left == null && del.right == null) { // Both are null node.left = null; } else { // Atleast one has something if (del.left == null && del.right != null) { // Has right but no left node.left = del.right; } else { if (del.right == null && del.left != null) { // Has left but no right node.left = del.left; } else { // Has both right and left if (del.left.right == null) { // Root left has no right del.left.right = del.right; node.left = del.left; } else { // Root left has a right BinaryNode leafRight = getLeafRight(del.left); node.left = leafRight.right; if (leafRight.right.left != null) { // This leaf has a left leafRight.right = leafRight.right.left; } leafRight.right = null; node.left.left = leafRight; node.left.right = del.right; } } } } } else { // Not this left // Check next one removeNode(node.left, pathNode, pathFvalue); } } } else { // Check right // Is it this right? if (node.right != null) { if (node.right.pathNode == pathNode) { // It's this right one! BinaryNode del = node.right; //debugCodePath += "RNR" + del + "; "; if (del.left == null && del.right == null) { // Both are null node.right = null; } else { // Atleast one has something if (del.left == null && del.right != null) { // Has right but no left node.right = del.right; } else { if (del.right == null && del.left != null) { // Has left but no right node.right = del.left; } else { // Has both right and left if (del.left.right == null) { // Root left has no right del.left.right = del.right; node.right = del.left; } else { // Root left has a right BinaryNode leafRight = getLeafRight(del.left); node.right = leafRight.right; if (leafRight.right.left != null) { // This leaf has a left leafRight.right = leafRight.right.left; } leafRight.right = null; node.right.left = leafRight; node.right.right = del.right; } } } } } else { // Not this right // Check next one removeNode(node.right, pathNode, pathFvalue); } } } }
//private string debugString; //private string debugCodePath; public BinaryTree() { //BinaryNode.nextId = 0; root = null; //debugCodePath = "NEW: "; }
private bool _conditionEndPointRightBranchChild(BinaryNode node) { return node.LeftChild != null && node.LeftChild.Type == NodeType.ConditionEndPoint && node.LeftChild.RightAncestor == node; }
private static GameObject LoadRecursionOnce(GameObject parentGo, BinaryNode domNode) { GameObject gameObject = null; string nodeAttr = GameSerializer.GetNodeAttr(domNode, "ON"); if (parentGo != null) { for (int i = 0; i < parentGo.transform.childCount; i++) { if (parentGo.transform.GetChild(i).name.Equals(nodeAttr)) { gameObject = parentGo.transform.GetChild(i).gameObject; break; } } } if (gameObject == null) { string nodeAttr2 = GameSerializer.GetNodeAttr(domNode, "PFB"); if (nodeAttr2 != null && nodeAttr2.get_Length() != 0) { object resource = GameSerializer.GetResource(nodeAttr2, typeof(GameObject)); if (resource == null || !(resource is GameObject)) { Debug.LogError(nodeAttr2 + " 不存在或者类型错误,请重新导出该场景"); gameObject = new GameObject(); } else { GameObject gameObject2 = resource as GameObject; bool activeSelf = gameObject2.activeSelf; gameObject2.SetActive(false); gameObject = (GameObject)Object.Instantiate(gameObject2); gameObject2.SetActive(activeSelf); } } else { gameObject = new GameObject(); } } Vector3 localScale = gameObject.transform.localScale; gameObject.name = GameSerializer.GetNodeAttr(domNode, "ON"); if (parentGo != null) { gameObject.transform.parent = parentGo.transform; } gameObject.transform.localScale = localScale; GameSerializer.DeserializeObject(domNode, gameObject); gameObject.SetActive(false); GameSerializer.InitComponets(domNode, gameObject); for (int j = 0; j < domNode.GetChildNum(); j++) { BinaryNode child = domNode.GetChild(j); if (child.GetName() == "CHD") { GameSerializer.LoadRecursionOnce(gameObject, child); } } return(gameObject); }
public List <BinaryNode> Find(BinaryNode root1, BinaryNode root2) { if (root1 == null || root2 == null) { return(new List <BinaryNode>()); } // Create two stacks for preorder traversals - we push nodes onto the stacks // until we find leaves, then we compare var s1 = new Stack <BinaryNode>(); s1.Push(root1); var s2 = new Stack <BinaryNode>(); s2.Push(root2); while (s1.Count > 0 && s2.Count > 0) { // not sure I understand this criteria given above while condition if (s1.Count == 0 || s2.Count == 0) { return(new List <BinaryNode>()); } // Do iterative traversal of first tree var temp1 = s1.Pop(); while (temp1 != null && temp1.IsLeaf() == false) { s1.Push(temp1.Right); s1.Push(temp1.Left); temp1 = s1.Pop(); } // Do iterative traversal of the second tree var temp2 = s2.Pop(); while (temp2 != null && temp2.IsLeaf() == false) { s2.Push(temp2.Right); s2.Push(temp2.Left); temp2 = s2.Pop(); } // if we found leaves in both trees if (temp1 != null && temp2 != null) { if (temp1.Value != temp2.Value) { return new List <BinaryNode>() { temp1, temp2 } } ; } } return(new List <BinaryNode>()); } }
public static object GetObject(BinaryNode currNode) { string nodeAttr = GameSerializer.GetNodeAttr(currNode, "NULL"); object obj = null; if (nodeAttr != null) { return(obj); } string nodeAttr2 = GameSerializer.GetNodeAttr(currNode, "Type"); string nodeAttr3 = GameSerializer.GetNodeAttr(currNode, "V"); string nodeAttr4 = GameSerializer.GetNodeAttr(currNode, "JT"); if ("Arr".Equals(nodeAttr4)) { if (nodeAttr2 != null) { string typeStr = nodeAttr2.Replace("[]", string.Empty); Type type = GameSerializer.GetType(typeStr); if (type == null) { Debug.LogError("Array type " + nodeAttr2 + " create failed!"); return(null); } Array array = Array.CreateInstance(type, currNode.GetChildNum()); for (int i = 0; i < array.get_Length(); i++) { array.SetValue(GameSerializer.GetObject(currNode.GetChild(i)), i); } obj = array; } } else if ("Cus".Equals(nodeAttr4)) { if (nodeAttr2 != null) { Type type2 = GameSerializer.GetType(nodeAttr2); ICustomizedObjectSerializer objectSerlizer = GameSerializer.GetObjectSerlizer(type2); if (objectSerlizer != null && objectSerlizer is ICustomInstantiate) { obj = ((ICustomInstantiate)objectSerlizer).Instantiate(currNode); } else { obj = GameSerializer.CreateInstance(type2); } if (obj == null) { return(null); } if (objectSerlizer != null) { objectSerlizer.ObjectDeserialize(ref obj, currNode); } } } else if ("Enum".Equals(nodeAttr4)) { if (nodeAttr2 != null) { Type type3 = GameSerializer.GetType(nodeAttr2); obj = Enum.ToObject(type3, int.Parse(nodeAttr3)); } } else if ("Pri".Equals(nodeAttr4)) { if (nodeAttr2 != null) { obj = Convert.ChangeType(nodeAttr3, GameSerializer.GetType(nodeAttr2)); } } else if ("Ref".Equals(nodeAttr4)) { Object gameObjectFromPath = GameSerializer.GetGameObjectFromPath(nodeAttr3, nodeAttr2); if (gameObjectFromPath != null) { if (gameObjectFromPath is GameObject) { if (nodeAttr2 != null) { string pureType = GameSerializer.GetPureType(nodeAttr2); if (!"GameObject".Equals(pureType)) { obj = (gameObjectFromPath as GameObject).GetComponent(pureType); if (obj == null) { Debug.LogError("No " + pureType + " component found in " + nodeAttr3); } } else { obj = gameObjectFromPath; } } } else { obj = gameObjectFromPath; } } else { obj = null; Debug.LogError("Load gameobject " + nodeAttr3 + " failed!"); } } else if ("Com".Equals(nodeAttr4)) { obj = GameSerializer.CreateInstance(nodeAttr2); if (obj == null) { return(null); } MemberInfo[] members = obj.GetType().GetMembers(); for (int j = 0; j < members.Length; j++) { if (GameSerializer.IsMINeedExport(members[j])) { BinaryNode binaryNode = currNode.SelectSingleNode(members[j].get_Name()); if (binaryNode != null) { try { object @object = GameSerializer.GetObject(binaryNode); if (binaryNode != null && @object != null) { GameSerializer.SetMIValue(members[j], obj, @object); } } catch (Exception ex) { Debug.LogError(string.Concat(new object[] { "Set field value failed! Field ", members[j].get_Name(), " in ", obj.GetType(), "e:", ex })); } } } } } return(obj); }
public void SetLeft(BinaryNode <T> left) { _left = left; }
public static IEnumerator GetObjectAsync(BinaryNode currNode, ObjectHolder holder) { GameSerializer.< GetObjectAsync > c__Iterator38 <GetObjectAsync> c__Iterator = new GameSerializer.< GetObjectAsync > c__Iterator38();
public Excercise2() { Root = null; }
public void SetRoot(BinaryNode node) { _root = node; }