public void ExportXml(TreeViewItem item)
        {
            exportXmlDocument = new XmlDocument();

            using (FileStream stream = new FileStream("QueryTreeViewNode.xml", FileMode.Create))
            {
                XmlDeclaration xmlDeclaration = exportXmlDocument.CreateXmlDeclaration("1.0", "UTF-8", null);
                exportXmlDocument.AppendChild(xmlDeclaration);

                NodeInfo ni = new NodeInfo() { Query = (string)item.Header, IsExpanded = item.IsExpanded };
                XmlElement xe = exportXmlDocument.CreateElement("item");
                xe.SetAttribute("name", ni.Query);

                if (item.IsExpanded)
                {
                    xe.SetAttribute("expand", "true");
                }
                // ルートノードをXmlDocumentに追加
                exportXmlDocument.AppendChild(xe);

                // 再帰的にツリーノードを読み込み、XmlDocument構築
                RecursiveTreeViewItemToXml(item, xe);

                // ファイルに出力
                exportXmlDocument.Save(stream);
            }
        }

		public void GetData(NodeInfo nodeInfo, CellInfo[] cellData)
		{
//			int commentCol = ShowLinks ? (int) FavoritesGridColumns.Comment
//				: (int) FavoritesGridColumns.Name;

			cellData[(int)FavoritesGridColumns.Name].Text = Name;
			cellData[(int)FavoritesGridColumns.Name].ImageIndex =
				Links.Count > 0
					? FavoritesDummyForm.Instance.FolderStartIndex
					: FavoritesDummyForm.Instance.EmptyFolderStartIndex;

			nodeInfo.Highlight = true;

//			if (ShowLinks)
//			{
//				cellData[(int) FavoritesGridColumns.ColSubj].Image = -1;
//				cellData[(int) FavoritesGridColumns.ColSubj].Text = string.Empty;
//				cellData[(int) FavoritesGridColumns.ColAuthor].Image = -1;
//				cellData[(int) FavoritesGridColumns.ColAuthor].Text = string.Empty;
//				cellData[(int) FavoritesGridColumns.ColDate].Image = -1;
//				cellData[(int) FavoritesGridColumns.ColDate].Text = string.Empty;
//				cellData[(int) FavoritesGridColumns.ColForum].Image = -1;
//				cellData[(int) FavoritesGridColumns.ColForum].Text = string.Empty;
//			}
//			cellData[commentCol].Text = Comment.ToString();
//			cellData[commentCol].Image = -1;

			cellData[(int)FavoritesGridColumns.Comment].Text = Comment;
		}

 public void AddFadingNode(FNode node, float showDuration)
 {
     NodeInfo info = new NodeInfo ();
     info.node = node;
     info.showDuration = showDuration;
     infos.Add (info);
 }

 public Position(NodeInfo nodeInfo, int i)
 {
     left = double.Parse(nodeInfo.data.ControlList[i].Position.Left);
     top = double.Parse(nodeInfo.data.ControlList[i].Position.Top);
     right = double.Parse(nodeInfo.data.ControlList[i].Position.Right);
     bottom = double.Parse(nodeInfo.data.ControlList[i].Position.Bottom);
 }

        public ContextMenuStrip CreateMenu(NodeInfo node)
        {
            ContextMenuStrip menu = new ContextMenuStrip();

            foreach (ContextAction action in this.actions)
            {
                if ((action.Controls.Count > 0) && !action.Controls.Contains(this.currentControl))
                {
                    continue;
                }

                if (!action.NoSelection)
                {
                    if (node == null)
                    {
                        continue;
                    }

                    if ((action.NodeType != 0) && !action.NodeType.HasFlag(node.Type))
                    {
                        continue;
                    }

                    if ((action.Predicate != null) && !action.Predicate(node))
                    {
                        continue;
                    }
                }

                ToolStripMenuItem item = this.CreateMenuItem(action, node);
                menu.Items.Add(item);
            }

            return menu;
        }

		public NodeInfoCollection GetChildren (NodeInfo root)
		{
			Trace.WriteLineIf (info.Enabled, "GroupingNodeFinder.GetChildren");
			NodeInfoCollection collection = null;

			switch (root.NodeType) {
			case NodeTypes.Type:
				GroupChildNodes (root);
				collection = new NodeInfoCollection ();
				collection.AddRange ((NodeInfoCollection)nodes[""]);
				AddGroup (nestedClasses, collection, root);
				AddGroup (baseNode, collection, root);
				AddGroup (interfacesNode, collection, root);
				AddGroup (constructorsNode, collection, root);
				AddGroup (methodsNode, collection, root);
				AddGroup (fieldsNode, collection, root);
				AddGroup (propertiesNode, collection, root);
				AddGroup (eventsNode, collection, root);
				return collection;
			case NodeTypes.Other:
				if (root.Description is GroupingInfo) {
					Trace.WriteLineIf (info.Enabled, "Found GroupingInfo");
					GroupingInfo g = (GroupingInfo) root.Description;
					collection = (NodeInfoCollection) nodes[g.Group];
					return collection;
				}
				break;
			}

			return finder.GetChildren (root);
		}

        public void CompareResults(List<NodeInfo> nodes, string outFile)
        {
            int pos = 0;
            XmlReader reader = XmlReader.Create(outFile);
            IXmlLineInfo li = (IXmlLineInfo)reader;
            XmlNodeType previousNodeType = XmlNodeType.None;
            using (reader) {
                while (reader.Read()) {
                    if (reader.NodeType == XmlNodeType.Whitespace ||
                        reader.NodeType == XmlNodeType.SignificantWhitespace ||
                        reader.NodeType == XmlNodeType.XmlDeclaration)
                        continue;

                    NodeInfo node = new NodeInfo(reader);
                    if (pos >= nodes.Count) {
                        throw new ApplicationException("Found too many nodes");
                    }
                    NodeInfo other = nodes[pos++];
                    if (!node.Equals(other)) {
                        throw new ApplicationException(
                                string.Format("Mismatching nodes at line {0},{1}",
                                li.LineNumber, li.LinePosition));
                    }
                    previousNodeType = node.NodeType;
                }
            }
        }

		protected override void AddTypeChildren (NodeInfoCollection c, NodeInfo parent, Type type)
		{
			object instance = parent.ReflectionInstance;

			foreach (MemberInfo mi in GetMembers (type)) {
				AddNode (c, parent, mi, instance);
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="NodeInfoEventArgs"/> class.
        /// </summary>
        /// <param name="nodeInfo">Node info.</param>
        public NodeInfoEventArgs(NodeInfo nodeInfo)
        {
            if (nodeInfo == null)
            {
                throw new ArgumentNullException("nodeInfo");
            }

            NodeInfo = nodeInfo;
        }

		public override NodeInfoCollection GetChildren (NodeInfo root)
		{
			// We don't want an infinite loop; quite showing children
			Trace.WriteLineIf (info.Enabled, "GetChildren for root.NodeType=" + root.NodeType);
			if (!CanShowChildren (root))
				return new NodeInfoCollection();

			return base.GetChildren (root);
		}

		static int CountType (NodeInfo root, NodeTypes type)
		{
			int count = 0;
			while (root != null) {
				if (root.NodeType == type)
					++count;
				root = root.Parent;
			}
			return count;
		}

		static bool InHistory (int count, NodeInfo root, params NodeTypes[] types)
		{
			while ((root != null) && (count-- != 0)) {
				foreach (NodeTypes t in types)
					if (root.NodeType == t)
						return true;
				root = root.Parent;
			}
			return false;
		}

		void IGetData.GetData(NodeInfo nodeInfo, CellInfo[] cellData)
		{
			cellData[OutboxManager.ForumColumn].Text = Source;
			cellData[OutboxManager.ForumColumn].ImageIndex = 
				OutboxImageManager.RegetTopicImageIndex;

			cellData[OutboxManager.SubjectColun].Text = Hint;
			
			cellData[OutboxManager.AddInfoColumn].Text = "ID = " + MessageID;
		}

		void IGetData.GetData(NodeInfo nodeInfo, CellInfo[] cellData)
		{
			var om = _provider.GetRequiredService<IOutboxManager>();
			cellData[0].Text = Description;
			cellData[0].ImageIndex = ImageIndex;
			cellData[1].Text = $"{(om.NewMessages.Count == 0 ? string.Empty : om.NewMessages.Count.ToString())}/{(om.RateMarks.Count == 0 ? string.Empty : om.RateMarks.Count.ToString())}/{(om.DownloadTopics.Count == 0 ? string.Empty : om.DownloadTopics.Count.ToString())}";

			nodeInfo.Highlight = (om.NewMessages.Count > 0)
				|| (om.RateMarks.Count > 0) || (om.DownloadTopics.Count > 0);
		}

        /// <summary>
        ///   Initializes a new instance of the <see cref="ReducedErrorPruning"/> class.
        /// </summary>
        /// 
        /// <param name="tree">The tree to be prunned.</param>
        /// <param name="inputs">The pruning set inputs.</param>
        /// <param name="outputs">The pruning set outputs.</param>
        /// 
        public ReducedErrorPruning(DecisionTree tree, double[][] inputs, int[] outputs)
        {
            this.tree = tree;
            this.inputs = inputs;
            this.outputs = outputs;
            this.info = new Dictionary<DecisionNode, NodeInfo>();
            this.actual = new int[outputs.Length];

            foreach (var node in tree)
                info[node] = new NodeInfo();

            for (int i = 0; i < inputs.Length; i++)
                trackDecisions(tree.Root, inputs[i], i);
        }

		public string GetDescription (NodeInfo node)
		{
			string r = "";
			switch (node.NodeType) {
			case NodeTypes.Type:
				r = GetTypeDescription ((Type)node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.BaseType:
				r = GetBaseTypeDescription ((Type)node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Interface:
				r = GetInterfaceDescription ((Type)node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Field:
				r = GetFieldDescription ((FieldInfo)node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Constructor:
				r = GetConstructorDescription ((ConstructorInfo)node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Method:
				r = GetMethodDescription ((MethodInfo) node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Parameter:
				r = GetParameterDescription ((ParameterInfo) node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Property:
				r = GetPropertyDescription ((PropertyInfo) node.ReflectionObject, node.ReflectionInstance);
				break;
			case NodeTypes.Event:
				r = GetEventDescription ((EventInfo) node.ReflectionObject, node.ReflectionInstance);
				break;
			/*
			case NodeTypes.CustomAttributeProvider:
				r = GetCustomAttributeProviderDescription ((ICustomAttributeProvider) node.ReflectionObject, node.ReflectionInstance);
				break;
			 */
			case NodeTypes.Other:
			case NodeTypes.Alias:
				r = GetOtherDescription (node);
				break;
			case NodeTypes.ReturnValue:
				r = GetReturnValueDescription (node);
				break;
			default:
				Debug.Assert (false, 
					String.Format ("Unhandled NodeInfo value: {0}", node.NodeType));
				break;
			}
			return r;
		}

 public ClusterMetadata GetClusterMetadata()
 {
     var req = CreateRequest("GetClusterMetadata");
     var resp = SendReceive(req);
     var sz = resp.ReadInt32();
     var list = new List<NodeInfo>(sz);
     for (int i = 0; i < sz; i++)
     {
         var node = new NodeInfo();
         node.Address = resp.ReadString();
         node.IsMaster = resp.ReadBoolean();
         list.Add(node);
     }
     return new ClusterMetadata(list);
 }

        private static NodeInfo createNodeInfo(DateTime? dt = null)
        {
            NodeInfo node = new NodeInfo();

            node.DiskAvailableFreeSpace = 100500;
            node.DiskUsage = 43.5;
            node.MemAvailable = 54.3;
            node.MemUsage = 34.2;
            node.Net = 3.14;
            node.Offline = false;
            node.ProcUsage = 76.8;
            node.SandBoxTotalSize = 455000;
            node.TimeSnapshot = dt ?? DateTime.Now;

            return node;
        }

		void SaveChildren (List<NodeInfo> info, TreePosition it)
		{
			int num = tree.DataSource.GetChildrenCount (it);
			for (int n=0; n<num; n++) {
				var child = tree.DataSource.GetChild (it, n);
				object id = tree.DataSource.GetValue (child, idColumn);
				NodeInfo ni = new NodeInfo ();
				ni.Id = id;
				ni.Expanded = tree.IsRowExpanded (child);
				ni.Selected = tree.IsRowSelected (child);
				info.Add (ni);
				if (tree.DataSource.GetChildrenCount (child) > 0) {
					ni.ChildInfo = new List<NodeInfo> ();
					SaveChildren (ni.ChildInfo, child);
				}
			}
		}

		void Save (List<NodeInfo> info, TreeIter it)
		{
			do {
				object id = tree.Model.GetValue (it, idColumn);
				NodeInfo ni = new NodeInfo ();
				ni.Id = id;
				ni.Expanded = tree.GetRowExpanded (tree.Model.GetPath (it));
				ni.Selected = tree.Selection.IterIsSelected (it);
				info.Add (ni);
				TreeIter cit;
				if (tree.Model.IterChildren (out cit, it)) {
					ni.ChildInfo = new List<NodeInfo> ();
					Save (ni.ChildInfo, cit);
				}
			}
			while (tree.Model.IterNext (ref it));
		}