예제 #1
0
        // 移除node
        public void RemoveElements(IList <T> elements)
        {
            foreach (var element in elements)
            {
                if (element == m_Root)
                {
                    throw new ArgumentException("It is not allowed to remove the root element");
                }
            }

            // 删除elements中,是其他节点的后代节点的节点
            // 返回的结果是新的list
            // (结果只保留顶级的父亲节点)
            var commonAncestors = TreeElementUtility.FindCommonAncestorsWithinList(elements);

            // 移除这些剩下的顶级节点
            // (这样做的,是为了避免重复的删除节点;
            // 如果删除了顶级节点,则在顶级节点下面的节点,就不用再删除了,因为已经随顶级节点被删除)
            foreach (var element in commonAncestors)
            {
                element.parent.children.Remove(element);
                element.parent = null;
            }

            // 树结构改变后,重新更新m_data
            TreeElementUtility.TreeToList(m_Root, m_Data);

            // 通知数据改变
            Changed();
        }
        public static void FindCommonAncestorsWithinListWorks()
        {
            // Arrange
            var list = new List <TestElement>();

            list.Add(new TestElement("root", -1));
            list.Add(new TestElement("A", 0));
            var b0 = new TestElement("B", 0);
            var b1 = new TestElement("Bchild", 1);
            var b2 = new TestElement("Bchildchild", 2);

            list.Add(b0);
            list.Add(b1);
            list.Add(b2);

            var c0 = new TestElement("C", 0);

            list.Add(c0);

            var f0 = new TestElement("F", 0);
            var f1 = new TestElement("Fchild", 1);
            var f2 = new TestElement("Fchildchild", 2);

            list.Add(f0);
            list.Add(f1);
            list.Add(f2);

            // Init tree structure: set children and parent properties
            TreeElementUtility.ListToTree(list);


            // Single element
            TestElement[] input          = { b1 };
            TestElement[] expectedResult = { b1 };
            var           result         = TreeElementUtility.FindCommonAncestorsWithinList(input).ToArray();

            Assert.IsTrue(ArrayUtility.ArrayEquals(expectedResult, result), "Single input should return single output");

            // Single sub tree
            input          = new[] { b1, b2 };
            expectedResult = new[] { b1 };
            result         = TreeElementUtility.FindCommonAncestorsWithinList(input).ToArray();
            Assert.IsTrue(ArrayUtility.ArrayEquals(expectedResult, result), "Common ancestor should only be b1 ");

            // Multiple sub trees
            input          = new[] { b0, b2, f0, f2, c0 };
            expectedResult = new[] { b0, f0, c0 };
            result         = TreeElementUtility.FindCommonAncestorsWithinList(input).ToArray();
            Assert.IsTrue(ArrayUtility.ArrayEquals(expectedResult, result), "Common ancestor should only be b0, f0, c0");
        }
예제 #3
0
        public void RemoveElements(IList <T> elements)
        {
            foreach (var element in elements)
            {
                if (element == m_Root)
                {
                    throw new ArgumentException("It is not allowed to remove the root element");
                }
            }

            var commonAncestors = TreeElementUtility.FindCommonAncestorsWithinList(elements);

            foreach (var element in commonAncestors)
            {
                element.parent.children.Remove(element);
                element.parent = null;
            }

            TreeElementUtility.TreeToList(m_Root, m_Data);

            Changed();
        }