public TreeNode(T Value)
{
this.Value = Value;
Parent = null;
Children = new TreeNodeList <T>(this);
_CallTree = new List <T>();
}
public TreeNode(T Value, TreeNode <T> Parent)
{
this.Value = Value;
this.Parent = Parent;
Children = new TreeNodeList <T>(this);
_CallTree = new List <T>();
}
public static String OrganizationList()
{
OrganizationListViewData view = new OrganizationListViewData();
view.List = new List <Organization>();
List <TreeNode> list;
view.PageData = new PaginationData();
view.PageData.PageIndex = 1;
view.PageData.PageSize = 10;
view.PageData.PagintionJsFunction = "window.System.OrganizationList.search()";
view.PageData.OrderBy = "Code";
string sql = @"SELECT Name AS Text, CAST(UnitGuid AS NVARCHAR(36)) AS ID, CAST(ParentGuid AS NVARCHAR(36)) AS ParentID, '<i class=''ace-icon ' + Icon + '''></i>' AS Icon FROM dbo.Organization ORDER BY Code";
using (DbConnectionScope dcs = new DbConnectionScope())
{
list = DbHelper.Db(sql).ToList <TreeNode>();
view.treeList = TreeNodeList.ToTreeNodeJson(list);
}
view.treeTitle = "组织架构";
TreeNode tr = list.FirstOrDefault();
if (tr == null)
{
tr = new TreeNode();
}
sql = @"SELECT A.*, B.Name AS ParentName
FROM dbo.Organization AS A
LEFT JOIN dbo.Organization AS B ON A.ParentGuid = B.UnitGuid
WHERE A.ParentGuid = @ParentGuid";
view.List = new Pagintion(sql, new { ParentGuid = tr.ID }, view.PageData).ToList <Organization>();
return(PageViewHelper.LoadPage("/System/OrganizationList.aspx", view));
}
public void Children_AfterCallingReplaceChildrenWithValidChildNodes_ReturnsSameInstance()
{
// ARRANGE
var node = new TreeNode <Byte>();
var nodeList1 = new TreeNodeList <Byte>(node)
{
new TreeNode <byte>("A", 1),
new TreeNode <byte>("B", 2),
new TreeNode <byte>("C", 3)
};
var nodeList2 = new TreeNodeList <Byte>(node)
{
new TreeNode <byte>("D", 4),
new TreeNode <byte>("E", 5),
new TreeNode <byte>("F", 6)
};
node.ReplaceChildren(nodeList1);
// ACT
node.ReplaceChildren(nodeList2);
// ASSERT
Assert.AreNotSame(nodeList1, node.Children);
Assert.AreSame(nodeList2, node.Children);
CollectionAssert.AreNotEqual(nodeList1, node.Children);
CollectionAssert.AreEqual(nodeList2, node.Children);
}
public static string Convert(this TreeNodeList model)
{
switch (model.Count)
{
case 0:
return(string.Empty);
case 1:
{
var wire = model[0].Convert();
return(wire);
}
default:
{
var sb = new StringBuilder();
for (var i = 0; i < model.Count; i++)
{
var text = model[i].Convert();
sb.AppendLine(text);
}
var wire = sb.ToString();
return(wire);
}
}
}
public static void ChasmSerializer_Roundtrip_TreeNodeList_Default(IChasmSerializer ser)
{
TreeNodeList expected = default;
using (var buf = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(buf.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_Roundtrip_TreeNodeList_2_Nodes(IChasmSerializer ser)
{
var expected = new TreeNodeList(Node1, Node2);
using (var buf = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(buf.Result);
Assert.Equal(expected, actual);
}
}
public static void ChasmSerializer_WriteRead_EmptyTreeNodeList(IChasmSerializer ser)
{
var expected = new TreeNodeList(new TreeNode[0]);
using (var seg = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(seg.Result);
Assert.Equal(expected, actual);
}
}
public void Children_AfterInstantiation_ReturnsNonNull()
{
// ARRANGE
var owner = new TreeNode <Byte>();
var nodeList = new TreeNodeList <Byte>(owner);
// ACT
var actual = nodeList.Nodes;
// ASSERT
Assert.IsNotNull(actual);
}
public void Children_AfterCallingAppend_ResultsInNotNull()
{
// ARRANGE
var node = new TreeNode <byte>();
TreeNodeList <Byte> children = new TreeNodeList <Byte>(node);
// ACT
node.AppendChildren(children);
// ASSERT
Assert.IsNotNull(node.Children);
}
public void ChildCount_AfterInstantiation_ReturnsZero()
{
// ARRANGE
var owner = new TreeNode <Byte>();
var nodeList = new TreeNodeList <Byte>(owner);
// ACT
var actual = nodeList.Count;
// ASSERT
Assert.AreEqual(0, actual);
}
public void Children_AfterCallingAppendChildrenWhenEmpty_ResultsInOnlyAppendedChildren()
{
// ARRANGE
var node = new TreeNode <byte>();
TreeNodeList <Byte> children = new TreeNodeList <Byte>(node);
// ACT
node.AppendChildren(children);
// ASSERT
CollectionAssert.AreEqual(children, node.Children);
}
public static void ChasmSerializer_WriteRead_TreeNodeList(IChasmSerializer ser)
{
var node0 = new TreeNode("a", NodeKind.Blob, Sha1.Hash("abc"));
var node1 = new TreeNode("b", NodeKind.Tree, Sha1.Hash("def"));
var node2 = new TreeNode("c", NodeKind.Tree, Sha1.Hash("hij"));
var expected = new TreeNodeList(node0, node1, node2);
using (var seg = ser.Serialize(expected))
{
var actual = ser.DeserializeTree(seg.Result);
Assert.Equal(expected, actual);
}
}
public BufferSession Serialize(TreeNodeList model)
{
var wire = model.Convert();
var maxLen = Encoding.UTF8.GetMaxByteCount(wire.Length); // Utf8 is 1-4 bpc
var rented = BufferSession.RentBuffer(maxLen);
var count = Encoding.UTF8.GetBytes(wire, 0, wire.Length, rented, 0);
var seg = new ArraySegment <byte>(rented, 0, count);
var session = new BufferSession(seg);
return(session);
}
private static void AssertEmpty(TreeNodeList treeNodeList)
{
Assert.Empty(treeNodeList);
Assert.Equal(TreeNodeList.Empty, treeNodeList); // By design
Assert.Equal(TreeNodeList.Empty.GetHashCode(), treeNodeList.GetHashCode());
Assert.Empty(treeNodeList.Keys);
Assert.Throws <IndexOutOfRangeException>(() => treeNodeList[0]);
Assert.Throws <KeyNotFoundException>(() => treeNodeList["x"]);
Assert.False(treeNodeList.TryGetValue("x", out _));
Assert.False(treeNodeList.TryGetValue("x", NodeKind.Blob, out _));
Assert.False(treeNodeList.Equals(new object()));
Assert.Contains("Count: 0", treeNodeList.ToString());
Assert.Equal(-1, treeNodeList.IndexOf(Guid.NewGuid().ToString()));
}
public void Children_AfterCallingAppendChildrenWhenNot_ResultsInAppendedChildrenAddedToEnd()
{
// ARRANGE
var node = new TreeNode <byte>();
TreeNodeList <Byte> originalChildren = new TreeNodeList <Byte>(node);
TreeNodeList <Byte> children = new TreeNodeList <Byte>(node);
node.AppendChildren(originalChildren);
// ACT
node.AppendChildren(children);
// ASSERT
Assert.IsNotNull(node.Children);
}
public static TreeWire Convert(this TreeNodeList model)
{
if (model.Count == 0)
{
return(new TreeWire());
}
var wire = new TreeWire();
for (var i = 0; i < model.Count; i++)
{
var node = model[i].Convert();
wire.Nodes.Add(node);
}
return(wire);
}
public BufferSession Serialize(TreeNodeList model)
{
var wire = model.Convert();
var size = wire.CalculateSize();
var buffer = BufferSession.RentBuffer(size);
using (var cos = new CodedOutputStream(buffer))
{
wire.WriteTo(cos);
var segment = new ArraySegment <byte>(buffer, 0, (int)cos.Position);
var session = new BufferSession(buffer, segment);
return(session);
}
}
public String SystemTree()
{
TreeViewData view = new TreeViewData();
view.Title = "系统";
string sql = @"SELECT Name AS Text, CAST(SystemGuid AS NVARCHAR(36)) AS ID, CAST(NULL AS NVARCHAR(36)) AS ParentID, '<i class=''ace-icon ''></i>' AS Icon
FROM dbo.SystemInfo
ORDER BY Code";
view.List = "[]";
using (DbConnectionScope dcs = new DbConnectionScope())
{
view.List = TreeNodeList.ToTreeNodeJson(DbHelper.Db(sql).ToList <TreeNode>());
}
return(PageViewHelper.LoadPage("/System/CommonPage/SingleSelectedTree.aspx", view));
}
public static JsonValue Convert(this TreeNodeList model)
{
if (model.Count == 0)
{
return(new JsonArray(Array.Empty <JsonValue>()));
}
var items = new JsonValue[model.Count];
for (var i = 0; i < items.Length; i++)
{
items[i] = model[i].Convert();
}
var wire = new JsonArray(items);
return(wire);
}
public String DepartmentTree()
{
TreeViewData view = new TreeViewData();
view.Title = "部门";
string sql = @"SELECT Name AS Text, CAST(UnitGuid AS NVARCHAR(36)) AS ID, CAST(ParentGuid AS NVARCHAR(36)) AS ParentID, '<i class=''ace-icon ' + Icon + '''></i>' AS Icon
FROM dbo.Organization
--WHERE ParentGuid IS NOT NULL
ORDER BY Code";
view.List = "[]";
using (DbConnectionScope dcs = new DbConnectionScope())
{
view.List = TreeNodeList.ToTreeNodeJson(DbHelper.Db(sql).ToList <TreeNode>());
}
return(PageViewHelper.LoadPage("/System/CommonPage/SingleSelectedTree.aspx", view));
}
public void Nodes_AfterReplaceChildrenWithChildNodes_ReturnsSameInstanceOfChildNodes()
{
// ARRANGE
var node = new TreeNode <byte>();
var children = new TreeNodeList <Byte>(node)
{
new TreeNode <byte>("A", 1),
new TreeNode <byte>("B", 2),
new TreeNode <byte>("C", 3)
};
// ACT
node.ReplaceChildren(children);
// ASSERT
Assert.AreSame(children[0], node.Children[0]);
Assert.AreSame(children[1], node.Children[1]);
Assert.AreSame(children[2], node.Children[2]);
}
public static void TreeNodeList_Empty()
{
var noData = new TreeNodeList();
AssertEmpty(noData);
var nullData = new TreeNodeList(null);
AssertEmpty(nullData);
var collData = new TreeNodeList((IList <TreeNode>)null);
AssertEmpty(collData);
var emptyData = new TreeNodeList(Array.Empty <TreeNode>());
AssertEmpty(emptyData);
Assert.Empty(TreeNodeList.Empty);
Assert.Equal(default, TreeNodeList.Empty);
public void Proc()
{
int nodeCount = int.Parse(Reader.ReadLine());
this.TreeNodeList = new TreeNode[nodeCount];
for (int i = 0; i < nodeCount; i++)
{
TreeNode t = new TreeNode(i, Reader.ReadLine().Split(' ').Select(a => long.Parse(a)).ToArray());
this.TreeNodeList[i] = t;
}
this.SortedX = TreeNodeList.OrderBy(a => a.X).ToArray();
this.SortedY = TreeNodeList.OrderBy(a => a.Y).ToArray();
List <Road> roadList = new List <Road>();
for (int i = 1; i < nodeCount; i++)
{
roadList.Add(new Road(SortedX[i - 1], SortedX[i]));
roadList.Add(new Road(SortedY[i - 1], SortedY[i]));
}
roadList = roadList.OrderBy(a => a.Length).ToList();
int cnt = 1;
long ans = 0;
foreach (Road r in roadList)
{
if (r.t1.Root.ID == r.t2.Root.ID)
{
continue;
}
r.t1.Join(r.t2);
ans += r.Length;
cnt++;
if (cnt >= nodeCount)
{
break;
}
}
Console.WriteLine(ans);
}
public TreeNodeList<Node> CreateNodeList(params TreeNode[] childs)
{
TreeNodeList<Node> nodelist = new TreeNodeList<Node>();
foreach (TreeNode child in childs)
{
if (child != null)
{
nodelist.Add(child);
}
}
return nodelist;
}
public TreeNodeList<Node> CreateNodeList(TreeNode child, TreeNodeList<Node> nl)
{
TreeNodeList<Node> nodelist = new TreeNodeList<Node>();
if (child != null)
{
nodelist.Add(child);
}
if (nl != null)
{
foreach (TreeNode node in nl)
{
if (node != null)
{
nodelist.Add(node);
}
}
}
return nodelist;
}
public TreeNode<Node> AppendChild(TreeNode par, TreeNodeList<Node> childs)
{
if (par != null && childs != null)
{
foreach(TreeNode child in childs)
{
par.Children.Add(child);
}
childs.Clear();
}
return par;
}
public TreeNode(T value)
{
this.Value = value;
children = new TreeNodeList(this);
}
/// <summary>Initializes a new instance of the <see cref="TreeNode{T}"/> class.</summary>
public TreeNode()
{
Children = new TreeNodeList(this);
}
public TreeBuilder()
{
BusinessObjectTree = new TreeNodeList();
}
public TreeNode(T value)
{
this.value = value;
m_parent = null;
m_children = new TreeNodeList(this);
}
public TreeNode CreateNode(int type, TreeNodeList<Node> tnl)
{
Node n = new Node();
n.type = type;
TreeNode node = new TreeNode(n);
m_stack.Add(node);
if (tnl != null)
{
foreach (TreeNode tn in tnl)
{
if (tn != null)
{
node.Children.Add(tn);
}
}
}
return node;
}
public Tree()
{
Nodes = new TreeNodeList();
Root = new TreeNode(strConfiguration, null);
Nodes.Add(Root);
}
public TreeNodeList<Node> AppendNodeList(TreeNodeList<Node> nl, params TreeNode[] nodes)
{
if (nl == null)
{
return CreateNodeList(nodes);
}
foreach (TreeNode node in nodes)
{
if (node != null)
{
nl.Add(node);
}
}
return nl;
}
