private static void PrintSolution(PathFinder pathFinder, INode result)
        {
            int steps = 0;
            INode node = result;

            if (node != null)
            {
                var stack = new Stack<INode>();

                do
                {
                    stack.Push(node);
                } while ((node = node.Parent) != null);

                Debug.WriteLine("8-Puzzle Solved in {0} Cycles", pathFinder.Cycles);
                Debug.WriteLine("-------------------------------------------");

                foreach (EightPuzzleNode solutionNode in stack)
                {
                    string tiles = solutionNode.Tiles
                        .Aggregate("", (current, i) => current + i.ToString());

                    Debug.WriteLine("{0:00} - {1} -  F: {2:00.0}  G: {3:00.0}  H: {4:00.0}",
                                    steps++,
                                    tiles,
                                    solutionNode.F, solutionNode.G, solutionNode.H);
                }
            }
            else
            {
                Debug.WriteLine("No solution");
            }
        }

 public SearcherResult(DateTime startTimeStamp, INode resultNode, string path, SearchOptions searchOptions)
 {
     StartTimestamp = startTimeStamp;
     ResultNode = resultNode;
     Path = path;
     SearchOptions = searchOptions;
 }

 public AStarNode(Location location, INode parent,
     decimal costFromStart, decimal costToGoal)
     : base(location, parent)
 {
     CostFromStart = costFromStart;
     CostToGoal = costToGoal;
 }

 public Transition(string identifier, bool isDefault, INode source, INode destination)
 {
     IsDefault = isDefault;
     Source = source;
     Destination = destination;
     Identifier = identifier;
 }

 public QuickRemove(ToolStripMenuItem menu, IGraph g, INode objNode, String file)
 {
     this._menu = menu;
     this._g = g;
     this._objNode = objNode;
     this._file = file;
 }

 internal SetPropertyValueOperation(INode node, string name, object oldvalue, object newvalue)
 {
     this.node = node;
     this.name = name;
     this.oldvalue = oldvalue;
     this.newvalue = newvalue;
 }

		public void Run(INode typeDeclaration)
		{
			typeDeclaration.AcceptVisitor(this, null);
			foreach (VariableDeclaration decl in fields) {
				decl.Name = prefix + decl.Name;
			}
		}

 public static string GetUriStringForNode(INode node)
 {
     if (node.IsEmpty()) return string.Empty;
     return string.Format("{0}://{1}:{2}", GetProtocolStringForTransportType(node.TransportType),
         GetHostStringForAddress(node.Host),
         node.Port);
 }

		public override bool DoMatch(INode other, Match match)
		{
			if (other == null || other.IsNull)
				return this.MinCount <= 0;
			else
				return this.MaxCount >= 1 && childNode.DoMatch(other, match);
		}

        public override INode AddNode(INode currentParent, IConverter converter)
        {
            INode orNode = new OrNode(converter);

            //// First element of a chain
            //if (currentParent is RootNode)
            //    throw new NotImplementedException("Or cannot be the first element");

            // Insert at root
            if (currentParent is RootNode)
            {
                var root = (currentParent as RootNode);
                var firstChild = root.Children.First();
                firstChild.Parent = orNode;
                (orNode as OrNode).Children.Add(firstChild);
                orNode.Parent = root;
                root.Children.Remove(firstChild);
            }
            // Insert before its parent
            else if (currentParent.Parent != null && currentParent.Parent as IMotherNode != null)
            {
                var grandParent = currentParent.Parent as IMotherNode;
                grandParent.Children.Remove(currentParent);
                (orNode as OrNode).Children.Add(currentParent);
                currentParent = currentParent.Parent;
            }

            this.LinkNodeToParent(currentParent, orNode);
            return orNode;
        }

		public static string ToText(INode node)
		{
			var output = new CSharpOutputVisitor();
			node.AcceptVisitor(output, null);

			return output.Text;
		}

		protected override void EndVisit(INode node)
		{
			if (node is PropertyGetRegion || node is PropertySetRegion) {
				this.currentContext = VisitorContext.Default;
			}
			base.EndVisit(node);
		}

        INode INodeCreator.CreateNode(Session session, INode parent, string name, IEnumerable<Property> properties)
        {
            if (parent != null && parent.ChildNodes[name] != null)
                throw new InvalidOperationException("Duplicated Child Node Name");

            return new Node(session, parent, name, properties, this.store);
        }

        IExpressionNode CreateNode(INode node)
        {
            IExpressionNode expressionNode = null;

            if (node is ExpressionStatement)
            {
                var statementNode = (ExpressionStatement)node;
                expressionNode = new StatementExpressionNode
                {
                    Expression = CreateNode(statementNode.Expression)
                };
            }
            else if (node is BinaryOperatorExpression)
            {
                var binaryNode = ((BinaryOperatorExpression)node);
                expressionNode = new BinaryExpressionNode
                {
                    Operator = (BinaryExpressionNode.Operators)binaryNode.Op,
                    Left = CreateNode(binaryNode.Left),
                    Right = CreateNode(binaryNode.Right),
                };
            }
            else if (node is PrimitiveExpression)
            {
                var primitiveNode = (PrimitiveExpression)node;
                var valueType = primitiveNode.Value == null ? typeof(object) : primitiveNode.Value.GetType();
                var value = (IValueNode)Activator.CreateInstance(typeof(ValueNode<>).MakeGenericType(valueType), primitiveNode.Value);
                expressionNode = new ValueExpressionNode
                {
                    Value = value,
                };
            }

            return expressionNode;
        }

 public void OnFocusedNodeChanged(INode inode)
 {
     if (focusedNodeChanged != null)
     {
         focusedNodeChanged(this, inode);
     }
 }

 public IEnumerable<Triple> GetTriplesWithSubjectPredicate(INode subj, INode pred)
 {
     Document lookup = new Document();
     lookup["graph.subject"] = this._formatter.Format(subj);
     lookup["graph.predicate"] = this._formatter.Format(pred);
     return new MongoDBGraphCentricEnumerable(this._manager, lookup, t => t.Subject.Equals(subj) && t.Predicate.Equals(pred));
 }

        public ImportSymbolSelectionDlg(INode[] nodes)
        {
            this.Build ();

            SetResponseSensitive(ResponseType.Ok, true);
            SetResponseSensitive(ResponseType.Cancel, true);

            buttonOk.GrabFocus();
            Modal = true;
            WindowPosition = Gtk.WindowPosition.CenterOnParent;

            // Init name column
            var nameCol = new TreeViewColumn();
            var textRenderer = new CellRendererText();
            nameCol.PackStart(textRenderer, true);
            nameCol.AddAttribute(textRenderer, "text", 0);
            list.AppendColumn(nameCol);

            // Init list model
            var nodeStore = new ListStore(typeof(string),typeof(INode));
            list.Model = nodeStore;

            // Fill list
            foreach (var n in nodes)
                if(n!=null)
                    nodeStore.AppendValues(n.ToString(), n);

            // Select first result
            TreeIter iter;
            if(nodeStore.GetIterFirst(out iter))
                list.Selection.SelectIter(iter);
        }

        public override INode AddNode(INode currentParent, IConverter converter)
        {
            //If the current parent is neither the root nor a group
            if(!(currentParent is IMotherNode))
                throw new ArgumentException("Trying to insert an 'AS' node, but the current node's type '" + currentParent.GetType() + "' is illegal. " + CheckString);

            GroupNode group;

            //If the current parent is the root
            if (currentParent is RootNode)
            {
                group = (currentParent as IMotherNode).Children.Last() as GroupNode;
                if (group == null)
                    throw new ArgumentException("Trying to insert an 'AS' node, but no Group found at root nor in its children. " + CheckString);
            }
            // The current parent is the group
            else if (currentParent is GroupNode)
                group = currentParent as GroupNode;
            // The group is the last child of the current parent
            else if ((currentParent as IMotherNode).Children.Last() is GroupNode)
                group = (currentParent as IMotherNode).Children.Last() as GroupNode;
            else
                throw new ArgumentException("Trying to insert an 'AS' node, but the current node is neither a group nor contains a group as children. " + CheckString);

            if (converter != null && converter.Function != null && converter.Function.Arguments != null && converter.Function.Arguments.Any())
                group.Name = converter.Function.Arguments[0].ToString();

            return currentParent;
        }

 internal static void Add(Identifier identifier, INode node)
 {
     if (_symbols.ContainsKey(identifier.Name))
         _symbols[identifier.Name] = node;
     else
         _symbols.Add(identifier.Name, node);
 }

        ////数字节点只能是叶子。
        //public GeneralNode(double number_p)
        //{
        //    number = number_p;
        //    left = right = null;
        //    isNumber = true;
        //    symbol = Esymbol.Nothing;
        //    priority = Epriority.Nothing;
        //}
        //操作符节点初始化
        public void SetUpNode(params object[] paras)//Esymbol symbol_p, INode left_p, INode right_p)
        {
            if (paras != null && paras.Length == 4)
            {
                if (paras[0] != null)
                {
                    number = (double)paras[0];
                    isNumber = true;
                }
                else
                {
                    isNumber = false;
                }

                left = (INode)paras[1];
                right = (INode)paras[2];

                if (paras[3] != null)
                {
                    symbol = (Esymbol)paras[3];
                }
                else
                {
                    symbol = Esymbol.Nothing;
                }

                priority = this.SymbolInPriority(symbol);
            }
            else
                throw new Exception("Node初始化参数数量对！");
        }