public override void visit(Tree.MethodDefinition that)
        {
            // TODO: virtual, abstract methods
            var name = that.getIdentifier().getToken().getText().CSharpMethodName();

            base.visit(that);
        }

		public override void PopulateTree (Tree tree)
		{
			XPathNavigator n = new XPathDocument (Path.Combine (basedir, "toc.xml")).CreateNavigator ();
			n.MoveToRoot ();
			n.MoveToFirstChild ();
			PopulateNode (n.SelectChildren ("node", ""), tree.RootNode);
		}

        public int Import(string filePath, int ownerId)
        {
            //Create GEDCOM Store
            var treeName = Path.GetFileNameWithoutExtension(filePath);
            var store = new GEDCOMStore(filePath);

            var treeService = _serviceFactory.CreateTreeService();

            var tree = new Tree() { Name = treeName, OwnerId = ownerId};
            treeService.Add(tree);

            _repositoryLookup = new Dictionary<int, int>();

            //Add Repositories
            ProcessRepositories(store.Repositories, tree.TreeId);

            _sourceLookup = new Dictionary<int, int>();

            //Add Sources
            ProcessSources(store.Sources, tree.TreeId);

            _individualLookup = new Dictionary<int, int>();

            //Add Individuals
            ProcessIndividuals(store.Individuals, tree.TreeId);

            //Add Families
            ProcessFamilies(store.Families, tree.TreeId);

            return tree.TreeId;
        }

        // Constructor for creating a new representative table. We directly fill the table depending on the given sequence.
        public RepresentativeTable(Graph graph, Tree tree)
        {
            // Initialize the table
            _table = new Dictionary<BitSet, RepresentativeList>();

            Queue<BitSet> queue = new Queue<BitSet>();
            queue.Enqueue(tree.Root);
            _table[new BitSet(0, graph.Size)] = new RepresentativeList();

            int i = 0;

            while (queue.Count != 0)
            {
                BitSet node = queue.Dequeue();

                FillTable(graph, node);
                FillTable(graph, graph.Vertices - node);

                if (tree.LeftChild.ContainsKey(node))
                {
                    queue.Enqueue(tree.LeftChild[node]);
                }
                if (tree.RightChild.ContainsKey(node))
                {
                    queue.Enqueue(tree.RightChild[node]);
                }
            }
        }

        public override sealed double Evaluate(Tree<SyntaxToken> tree, EvaluationContext context)
        {
            var leaf = tree.Leafs[0];
            double value = leaf.Value.Evaluate(leaf, context);

            return Evaluate(value);
        }

        public void WriteTable(Tree<Cell> table) {
            var tableResult = processor.ParseTree<Cell, StoryTableString>(table).ToString();
            if (string.IsNullOrEmpty(tableResult)) return;

            HandleTableResult(tableResult);
            writesTables = true;
        }

 public Tree TransformTree(Tree t)
 {
     TregexMatcher matcher = TregexMonthYear.Matcher(t);
     while (matcher.Find())
     {
         Tree root = matcher.GetNode("root");
         Tree month = matcher.GetNode("month");
         Tree year = matcher.GetNode("year");
         var children = new Tree[] {month, year};
         root.SetChildren(children);
         matcher = TregexMonthYear.Matcher(t);
     }
     matcher = TregexMonthDayYear.Matcher(t);
     while (matcher.Find())
     {
         Tree root = matcher.GetNode("root");
         Tree month = matcher.GetNode("month");
         Tree day = matcher.GetNode("day");
         Tree comma = matcher.GetNode("comma");
         Tree year = matcher.GetNode("year");
         var children = new Tree[] {month, day, comma, year};
         root.SetChildren(children);
         matcher = TregexMonthDayYear.Matcher(t);
     }
     return t;
 }

        public static string ComputeId(Tree tree)
        {
            using (var md = new MessageDigest())
            {
                using (var ms = new MemoryStream())
                {
                    foreach (var item in tree.Items)
                    {
                        var data = Encoding.Default.GetBytes(string.Format("{0} {1}\0", item.Mode, item.Name));
                        ms.Write(data, 0, data.Length);

                        var id = Helper.IdToByteArray(item.Id);
                        ms.Write(id, 0, id.Length);
                    }

                    var header = Encoding.Default.GetBytes(string.Format("tree {0}\0", ms.Length));
                    ms.Position = 0;
                    md.Update(header);
                    md.Update(ms);
                }
                var digest = md.Digest();

                return Helper.ByteArrayToId(digest);
            }
        }

        static void Main()
        {
            Tree<int> tree =
            new Tree<int>(3,
                          new Tree<int>(5,
                                        new Tree<int>(0),
                                        new Tree<int>(1),
                                        new Tree<int>(6)),
                          new Tree<int>(2,
                                        new Tree<int>(4)));

            Console.WriteLine("Depth-First Search (DFS) traversal (recursive):");
            tree.TraverseDFS();
            Console.WriteLine();

            Console.WriteLine("Breadth-First Search (BFS) traversal (with queue):");
            tree.TraverseBFS();
            Console.WriteLine();

            Console.WriteLine();
            Console.WriteLine("Depth-First Search (DFS) traversal (with stack):");
            tree.TraverseDFSWithStack();
            Console.WriteLine();

            Console.WriteLine("Root: {0}", tree.Root.Value);

            Console.Write("Leafs: ");
            tree.TraverseLeafs(tree.Root);
            Console.WriteLine();
        }

        private static void DisplayTree(Tree<int> tree)
        {
            var serializer = new XmlSerializer(tree.GetType());
            serializer.Serialize(Console.Out, tree);

            Console.WriteLine();
        }

		public void NonFullRootNodeTest ()
		{
			var tree = new Tree<int, string>(new TreeMemoryNodeManager<int, string>(2, Comparer<int>.Default),
				allowDuplicateKeys: true);

			tree.Insert (1, "1");

			Assert.AreEqual (0, (from node in tree.LargerThan(7) select node).Count());
			Assert.AreEqual (0, (from node in tree.LargerThanOrEqualTo(7) select node).Count());
			Assert.AreEqual (1, (from node in tree.LessThan(7) select node).FirstOrDefault().Item1);
			Assert.AreEqual (1, (from node in tree.LessThanOrEqualTo(7) select node).FirstOrDefault().Item1);
			Assert.AreEqual (1, (from node in tree.LessThanOrEqualTo(1) select node).FirstOrDefault().Item1);
			Assert.AreEqual (0, (from node in tree.LessThan(1) select node).Count());

			tree.Insert (5, "5");
			tree.Insert (9, "9");

			// 1,5,9

			Assert.IsTrue ((from node in tree.LessThanOrEqualTo(9) select node.Item1).SequenceEqual(new int[] { 9, 5, 1 }));
			Assert.IsTrue ((from node in tree.LessThan(9) select node.Item1).SequenceEqual(new int[] { 5, 1 }));
			Assert.IsTrue ((from node in tree.LargerThanOrEqualTo(5) select node.Item1).SequenceEqual(new int[] { 5, 9 }));
			Assert.IsTrue ((from node in tree.LargerThan(5) select node.Item1).SequenceEqual(new int[] { 9 }));


			Assert.DoesNotThrow(delegate {
				tree.Insert (5, "5.1");
			});

			// Iterating test
			var found = (from node in tree.LargerThanOrEqualTo(5) select node.Item2).ToList ();
			Assert.AreEqual (3, found.Count);
			Assert.IsTrue (found.Contains("5.1"));
			Assert.IsTrue (found.Contains("5"));
		}

 public static void DoTable(Tree<Cell> table, Interpreter activeFixture, bool inFlow)
 {
     var activeFlowFixture = activeFixture as FlowInterpreter;
     if (activeFlowFixture != null) activeFlowFixture.DoSetUp(table);
     activeFixture.Interpret(table);
     if (activeFlowFixture != null && !inFlow) activeFlowFixture.DoTearDown(table);
 }

		public override void PopulateTree (Tree tree)
		{
			var doc = XDocument.Load (tocFile);
			var uls = doc.Descendants (ns + "body").First ().Elements (ns + "ul");
			foreach (var ul in uls)
				ParseUl (tree, tree.RootNode, ul);
		}

 public void Interpret(CellProcessor processor, Tree<Cell> table)
 {
     new Traverse<Cell>()
         .Rows.Header(row => headerRow = row)
         .Rows.Rest(row => ComputeRow(processor, row))
         .VisitTable(table);
 }

    public void BuildTree_PrintTree_ShouldWorkCorrectly()
    {
        // Arrange
        var tree =
            new Tree<int>(7,
                new Tree<int>(19,
                    new Tree<int>(1),
                    new Tree<int>(12),
                    new Tree<int>(31)),
                new Tree<int>(21),
                new Tree<int>(14,
                    new Tree<int>(23),
                    new Tree<int>(6)));

        // Act
        var outputStream = new MemoryStream();
        using (var outputWriter = new StreamWriter(outputStream))
        {
            Console.SetOut(outputWriter);
            tree.Print();
        }
        var output = Encoding.UTF8.GetString(outputStream.ToArray());

        // Assert
        var expectedOutput = "7\n  19\n    1\n    12\n    31\n  21\n  14\n    23\n    6\n";
        output = output.Replace("\r\n", "\n");
        Assert.AreEqual(expectedOutput, output);
    }

 private static Map Iterate(ConcurrentQueue<Tuple<Map, char>> queue, Tree tree)
 {
     Tuple<Map, char> var;
     while (!queue.TryDequeue(out var)) System.Threading.Thread.Sleep(5);
     var currentMap = var.Item1;
     var cars = currentMap.Parse();
       //Console.WriteLine("Checking:\n" + currentMap);
     if (cars.ContainsKey(Globals.TargetCar) && cars[Globals.TargetCar].Item1.Equals(targetLocation))
         return currentMap;
     foreach (var kvp in cars)
         if (kvp.Key != var.Item2) {
             Map move;
             bool horizontal = kvp.Value.Item3 == Direction.Right;
             for (int i = 1; i <= (horizontal ? kvp.Value.Item1.X : kvp.Value.Item1.Y); i++) {
                 move = currentMap.makeMove(kvp.Key, kvp.Value.Item1, kvp.Value.Item3.Invert(), kvp.Value.Item2, i);
                 if (move != null) {
                     NewMethod(queue, tree, currentMap, kvp, move);
                 }
                 else break;
             }
             for (int i = 1; i < (horizontal ? map.map.GetLength(0) - kvp.Value.Item1.X : map.map.GetLength(1) - kvp.Value.Item1.Y); i++) {
                 move = currentMap.makeMove(kvp.Key, kvp.Value.Item1, kvp.Value.Item3, kvp.Value.Item2, i);
                 if (move != null) {
                     NewMethod(queue, tree, currentMap, kvp, move);
                 }
                 else break;
             }
         }
     if (queue.Count == 0) return Globals.NoSolutions; // We don't have anything to add
     return null; // no solution found yet
 }

        public static void SaveTree(String TreeXml)
        {
            if (String.IsNullOrEmpty(TreeXml))
            {
                //创建一棵空树
                XElement root = new XElement("root");
                TreeXml = root.ToString();
            }

            using (InfocenterEntities context = new InfocenterEntities(DALConfig.ConnectString))
            {
               Tree treeObj = context.Trees.FirstOrDefault();
               if (treeObj != null)
               {
                   //更新树
                   treeObj.maintree = Encoding.UTF8.GetBytes(TreeXml);
                   context.SaveChanges();
               }
               else
               {
                   //正常情况下应该不会走到这个分支，但仍然写在这里，逻辑就完整了。
                   treeObj = new Tree();
                   treeObj.maintree = Encoding.UTF8.GetBytes(TreeXml);
                   context.Trees.Add(treeObj);
                   context.SaveChanges();
               }

            }
        }

    static void Main()
    {
        Node<int> root = new Node<int>(5);
        Tree<int> tree = new Tree<int>(root);

        tree.Add(new Node<int>(7));
        tree.Add(new Node<int>(1));
        tree.Add(new Node<int>(2));
        tree.Add(new Node<int>(9));
        tree.Add(new Node<int>(4));
        tree.Add(new Node<int>(8));
        tree.Add(new Node<int>(0));
        tree.Add(new Node<int>(11));
        tree.Add(new Node<int>(-3));
        tree.Add(new Node<int>(-6));
        tree.Add(new Node<int>(-5));
        tree.Add(new Node<int>(-8));
        tree.Add(new Node<int>(5));
        tree.Add(new Node<int>(12));

        tree.Print();
        tree.FindLongestPath();

        Console.WriteLine("++++++++++++++++++++++++++++");

        var allSubTreessWithSum = tree.FindSubtreesWithSum(-10);

        foreach (var subTree in allSubTreessWithSum)
        {
            subTree.Print();
        }
    }

 public void SetLastIndex(Tree t)
 {
     lastIndex = 0;
     var iterator = t.Iterator();
     while (iterator.MoveNext())
     {
         var node = iterator.Current;
         /*foreach (Tree node in t) {*/
         string value = node.Label().Value();
         if (value != null)
         {
             var m = coindexationPattern.Match(value);
             if (m.Success)
             {
                 int thisIndex = 0;
                 try
                 {
                     thisIndex = int.Parse(m.Groups[1].Value);
                 }
                 catch (FormatException e)
                 {
                     // Ignore this exception.  This kind of exception can
                     // happen if there are nodes that happen to have the
                     // indexing character attached, even despite the attempt
                     // to ignore those nodes in the pattern above.
                 }
                 lastIndex = Math.Max(thisIndex, lastIndex);
             }
         }
     }
 }

        private void bindPages( List<Page> list )
        {
            Tree<Page> tree = new Tree<Page>( list );

            IBlock block = getBlock( "list" );
            foreach (Page data in tree.GetAllOrdered()) {

                block.Set( "data.Id", data.Id );
                block.Set( "data.OrderId", data.OrderId );

                block.Set( "data.AddSubLink", to( AddSubPage, data.Id ) );

                int indentLength = tree.GetDepth( data.Id ) * 20;
                String indent = "padding-left:" + indentLength + "px";
                block.Set( "data.Indent", indent );

                block.Set( "data.Title", data.Title );
                block.Set( "data.Created", data.Created );
                block.Set( "data.Hits", data.Hits );
                block.Set( "data.ReplyCount", data.Replies );
                block.Set( "data.IsAllowReplyStr", data.IsAllowReplyStr );

                block.Set( "data.ViewUrl", to( ViewUrl, data.Id ) );

                block.Set( "data.LinkShow", plink( data.Id ) );
                block.Set( "data.LinkDelete", to( Delete, data.Id ) );
                block.Set( "data.LinkEdit", to( Edit, data.Id ) );

                block.Next();

            }
        }