private static IdTree CreateRandomTree(int numberOfLevels, int maximumNumberOfNodes) { if (_idCount >= maximumNumberOfNodes) { return(null); } var randomTree = new IdTree { RootNode = new IdNode { Id = _idCount++ } }; if (numberOfLevels == 0) { return(randomTree); } var numberOfChildren = RandomNumber.Between(1, 5); var nextLevel = numberOfLevels - 1; for (int i = 0; i < numberOfChildren; i++) { var tree = CreateRandomTree(nextLevel, maximumNumberOfNodes); if (tree != null) { tree.RootNode.Parent = randomTree.RootNode; randomTree.RootNode.Children.Add(tree.RootNode); } } return(randomTree); }
private void AddChildToNonRootParent(int parentId, IdNode node, IdTree tree) { var parent = _deserializedNodes[parentId]; node.Parent = parent; parent.Children.Add(node); }
private void DeserializeIntoTree(BinaryReader binaryReader, IdTree tree) { //nodes need to be deserialized in the same order they were serialized. In this case, the parent node id is serialized first //followed by the current node id. Only the root node has no parent. var parentId = ReadInt(binaryReader); var currentNodeId = ReadInt(binaryReader); if (parentId == -1 || currentNodeId == -1) { return; } var node = new IdNode { Id = currentNodeId }; _deserializedNodes.Add(currentNodeId, node); AddChildNodeToParent(parentId, node, tree); if (binaryReader.BaseStream.Position != binaryReader.BaseStream.Length) { DeserializeIntoTree(binaryReader, tree); } }
public void CanCreateIdTreeWithSingleNode() { const int rootNodeId = 1; var idNode = new IdNode(rootNodeId); var idTree = new IdTree(idNode); Assert.IsNotNull(idTree); Assert.That(idTree.RootNode.Id, Is.EqualTo(rootNodeId)); }
private void AddChildNodeToParent(int parentId, IdNode node, IdTree tree) { if (parentId == tree.RootNode.Id) { AddChildToRoot(node, tree); } else { AddChildToNonRootParent(parentId, node, tree); } }
public void CanSerializeEmptyTree() { var idTree = new IdTree(); var serializer = new IdTreeSerializer(); byte[] serializedIdTree = serializer.Serialize(idTree); int deserializedId = BitConverter.ToInt32(serializedIdTree, 0); Assert.That(deserializedId, Is.EqualTo(IdNode.EmptyNodeId)); }
public byte[] Serialize(IdTree tree) { using (var memoryStream = new MemoryStream()) { using (var binaryWriter = new BinaryWriter(memoryStream)) { SerializeNode(tree.RootNode, binaryWriter); } return(memoryStream.ToArray()); } }
private void AddChildToNonRootParent(int parentId, IdNode node, IdTree tree) { var parentNode = tree.FindNode(parentId); if (parentNode == null) { return; } node.Parent = parentNode; parentNode.Children.Add(node); }
private IdTree BuildBomberTree() { var bomber = new IdNode(100); var fuselage = new IdNode(200, bomber); var engineerFuselage = new IdNode(300, fuselage); var testFuselage = new IdNode(400, fuselage); var bombs = new IdNode(500, bomber); var engineerBombs = new IdNode(600, bombs); var testBombs = new IdNode(700, bombs); var wbsTree = new IdTree(bomber); return(wbsTree); }
public void CanSerializeTreeWithSingleNodeWithNoParentAndNoChildren() { const int rootNodeId = 100; var rootNode = new IdNode(rootNodeId); var idTree = new IdTree(rootNode); var serializer = new IdTreeSerializer(); byte[] serializedIdTree = serializer.Serialize(idTree); int actualRootNodeId = BitConverter.ToInt32(serializedIdTree, 0); int actualParentNodeId = BitConverter.ToInt32(serializedIdTree, 4); Assert.That(actualRootNodeId, Is.EqualTo(rootNodeId)); Assert.That(actualParentNodeId, Is.EqualTo(IdNode.EmptyNodeId)); }
public IdTree Deserialize(byte[] treeBytes) { _watch.Reset(); _watch.Start(); var deserializedTree = new IdTree(); using (var memoryStream = new MemoryStream(treeBytes)) { using (var binaryReader = new BinaryReader(memoryStream)) { var rootnode = new IdNode { Id = binaryReader.ReadInt32() }; deserializedTree.RootNode = rootnode; DeserializeIntoTree(binaryReader, deserializedTree); } } _watch.Stop(); return(deserializedTree); }
public void CanDeserializeWbsTree() { IdTree bomberTree = BuildBomberTree(); var serializer = new IdTreeSerializer(); byte[] serializedBomber = serializer.Serialize(bomberTree); IdTree deserializedBomberTree = serializer.DeSerialize(serializedBomber); Assert.IsNotNull(deserializedBomberTree.RootNode); IdNode bomber = deserializedBomberTree.RootNode; Assert.That(bomber.Id, Is.EqualTo(100)); IdNode fuselage = bomber.Children[0]; Assert.That(fuselage.Id, Is.EqualTo(200)); Assert.That(fuselage.Parent.Id, Is.EqualTo(100)); IdNode engineerFuselage = fuselage.Children[0]; Assert.That(engineerFuselage.Id, Is.EqualTo(300)); IdNode testFuselage = fuselage.Children[1]; Assert.That(testFuselage.Id, Is.EqualTo(400)); IdNode bombs = bomber.Children[1]; Assert.That(bombs.Id, Is.EqualTo(500)); IdNode engineerBombs = bombs.Children[0]; Assert.That(engineerBombs.Id, Is.EqualTo(600)); IdNode testBombs = bombs.Children[1]; Assert.That(testBombs.Id, Is.EqualTo(700)); }
public void CanSerializeTreeWithOneChild() { const int rootNodeId = 100; const int childNodeId = 200; var rootNode = new IdNode(rootNodeId); var childNode = new IdNode(childNodeId, rootNode); var idTree = new IdTree(rootNode); var serializer = new IdTreeSerializer(); byte[] serializedIdTree = serializer.Serialize(idTree); int actualRootNodeId = BitConverter.ToInt32(serializedIdTree, 0); int actualParentNodeId = BitConverter.ToInt32(serializedIdTree, 4); int actualChildCount = BitConverter.ToInt32(serializedIdTree, 8); int actualChildId = BitConverter.ToInt32(serializedIdTree, 12); Assert.That(actualRootNodeId, Is.EqualTo(rootNodeId)); Assert.That(actualParentNodeId, Is.EqualTo(IdNode.EmptyNodeId)); Assert.That(actualChildCount, Is.EqualTo(1)); Assert.That(actualChildId, Is.EqualTo(childNodeId)); }
private static void PrintTree(IdTree tree) { string indent = string.Empty; Print(tree.RootNode, indent, tree.RootNode.Children.Any()); }
private static IdTree CreateStaticTestTree() { var tree = new IdTree(); var rootNode = new IdNode { Id = 1 }; var secondNode = new IdNode { Id = 2, Parent = rootNode }; secondNode.Children = new List <IdNode> { new IdNode { Id = 5, Parent = secondNode }, new IdNode { Id = 6, Parent = secondNode }, new IdNode { Id = 7, Parent = secondNode } }; rootNode.Children.Add(secondNode); var thirdNode = new IdNode { Id = 3, Parent = rootNode }; thirdNode.Children = new List <IdNode> { new IdNode { Id = 8, Parent = thirdNode }, new IdNode { Id = 9, Parent = thirdNode }, }; rootNode.Children.Add(thirdNode); var fourthNode = new IdNode { Id = 4, Parent = rootNode }; fourthNode.Children = new List <IdNode> { new IdNode { Id = 10, Parent = fourthNode }, new IdNode { Id = 11, Parent = fourthNode }, }; var forthNodeChildWithChildren = new IdNode { Id = 12, Parent = fourthNode }; forthNodeChildWithChildren.Children = new List <IdNode> { new IdNode { Id = 13, Parent = forthNodeChildWithChildren }, new IdNode { Id = 14, Parent = forthNodeChildWithChildren } }; fourthNode.Children.Add(forthNodeChildWithChildren); rootNode.Children.Add(fourthNode); rootNode.Children.Add(new IdNode { Id = 15, Parent = rootNode }); tree.RootNode = rootNode; return(tree); }
private static void AddChildToRoot(IdNode node, IdTree tree) { node.Parent = tree.RootNode; tree.RootNode.Children.Add(node); }
public void CanCreateEmptyIdTree() { var idTree = new IdTree(); Assert.That(idTree.RootNode.Id, Is.EqualTo(IdNode.EmptyNodeId)); }