public override bool PublishCommentPost(UserInfo u, string msg, PostInfo p) { NTree <PostInfo> node = null; List <PostInfo> result = new List <PostInfo>(); if (msg == "") { return(false); } tree.traverse(delegate(NTree <PostInfo> curnode) { if (curnode.getData() != null && curnode.getData().id == p.id) { node = curnode; } }); if (node == null) { return(false); } ; node.addChild(new PostInfo { id = Int2Guid(postnum++), msg = msg, owner = memb }); return(true); }
internal static NTree <int> Execute <TEdge>(Graph <TEdge> graph, int startingNode) where TEdge : IEdge { var root = new NTree <int>(startingNode); var marked = new bool[graph.CountOfNodes]; marked[startingNode] = true; var queue = new Queue <NTree <int> >(graph.CountOfNodes); queue.Enqueue(root); while (queue.Count > 0) { var currentTree = queue.Dequeue(); var notVisitedQuery = graph.GetAdjacentNodes(currentTree.Value) .Where(w => !marked[w]); foreach (var childIndex in notVisitedQuery) { marked[childIndex] = true; var child = new NTree <int>(childIndex); currentTree.ChildsList.Add(child); queue.Enqueue(child); } } return(root); }
public void NTreeDeletesByIndexIndividualUnique() { var objs = TestResourceFactory.GetMockClassAObjects(50).ToList(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); objs.ForEach(o => o.Id = seedIndex.Increment()); using (var tree = new NTree<int, MockClassA, long>("Id", true)) { foreach (var o in objs) tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment())); Assert.AreEqual(50, tree.Length); Assert.AreEqual(5, tree.GetFirstByIndex(5)); Assert.AreEqual(5, tree.GetFirstBySegment(5)); Assert.AreEqual(1, tree.GetByIndex(5).Count()); Assert.AreEqual(1, tree.Delete(5).Length); Assert.AreEqual(50, tree.Length); Assert.AreEqual(0, tree.GetFirstByIndex(5)); } }
public void Equals_NTreeDifferentStructure_Returns_False() { // Arrange var values = new[] { 0, 1, 2, 3, 4 }; var otherTree = new NTree <int>(values[0], new List <NTree <int> > { new NTree <int>(values[1]), new NTree <int>(values[2]), new NTree <int>(values[3]), new NTree <int>(values[4]), }); var sut = new NTree <int>(values[0], new List <NTree <int> > { new NTree <int>(values[1], new List <NTree <int> > { new NTree <int>(values[2]), }), new NTree <int>(values[3], new List <NTree <int> > { new NTree <int>(values[4]), }), }); // Act var result = sut.Equals(otherTree); // Assert Assert.False(result); }
public void NTreeFetchesByIndexRange() { var objs = TestResourceFactory.GetMockClassAObjects(5000).ToList(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); objs.ForEach(o => o.Id = seedIndex.Increment()); var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList(); using (var tree = new NTree<int, MockClassA, long>("Id")) { var ids = tree.AddOrUpdateRange(toAdd); Assert.AreEqual(5000, tree.Length); Assert.AreEqual(5, tree.GetFirstByIndex(5)); Assert.AreEqual(5, tree.GetFirstBySegment(5)); Assert.AreEqual(1, tree.GetByIndex(5).Count()); tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment())); Assert.AreEqual(5001, tree.Length); long[] loc; var range = tree.GetByIndexRangeInclusive(51, 250, out loc); Assert.AreEqual(200, range.Length); } }
public void NTreeChecksAllWithLargeCount() { using (var tree = new NTree<int, MockClassA, long>("Id", true)) { var objs = new List<MockClassA>(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); for (var i = 0; i < 5; i++) { var additions = TestResourceFactory.GetMockClassAObjects(100000).ToList(); additions.ForEach(o => o.Id = seedIndex.Increment()); tree.AddOrUpdateRange(additions.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList()); } Assert.AreEqual(500000, tree.Length); Assert.AreEqual(5, tree.GetFirstByIndex(5)); Assert.AreEqual(5, tree.GetFirstBySegment(5)); Assert.AreEqual(1, tree.GetByIndex(5).Count()); tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment())); Assert.AreEqual(500001, tree.Length); tree.AddOrUpdateRange( tree.AsEnumerable().First().Take(100) .Select(s => new NTreeItem<int, long>(s.Item2.Index, s.Item2.Segment)) .ToList()); Assert.AreEqual(500001, tree.Length); } }
public void ByLevel_ThreeLevels_ThreeChildsPerLevels() { // Arrange var values = Enumerable.Range(0, 13).ToArray(); var sut = new NTree <int>(values[0], new List <NTree <int> > { new NTree <int>(values[1], new List <NTree <int> > { new NTree <int>(values[4]), new NTree <int>(values[5]), new NTree <int>(values[6]), }), new NTree <int>(values[2], new List <NTree <int> > { new NTree <int>(values[7]), new NTree <int>(values[8]), new NTree <int>(values[9]), }), new NTree <int>(values[3], new List <NTree <int> > { new NTree <int>(values[10]), new NTree <int>(values[11]), new NTree <int>(values[12]), }), }); // Act var result = sut.ByLevel; // Assert Assert.True(result.SequenceEqual(values)); }
public void ByLevel_UnEvenTree() { // Arrange var values = Enumerable.Range(0, 7).ToArray(); var sut = new NTree <int>(values[0], new List <NTree <int> > { new NTree <int>(values[1], new List <NTree <int> > { new NTree <int>(values[4]), }), new NTree <int>(values[2]), new NTree <int>(values[3], new List <NTree <int> > { new NTree <int>(values[5]), new NTree <int>(values[6]), }), }); // Act var result = sut.ByLevel; // Assert Assert.True(result.SequenceEqual(values)); }
private void GetTitle(NTree tree, out string title, out string subText, out string activateText) { var type = tree.Type; switch (type) { case TreeType.Skill: title = "SKILLS"; subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0"); activateText = "unlock skill / customise skill"; break; case TreeType.Weapon: title = "WEAPONS"; subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0"); activateText = "unlock weapon / customise weapon"; break; case TreeType.SkillMod: var s = RPG.PlayerData.GetSkill(tree.TreeRef); title = s.Name; subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0"); activateText = "unlock skill mod"; break; default: throw new ArgumentOutOfRangeException(type.ToString()); } }
private NTree <ItemDto> SearchFoldersInternal(int portalId, string searchText, int sortOrder, string permission) { var tree = new NTree <ItemDto> { Data = new ItemDto { Key = RootKey } }; if (portalId > -1) { if (!IsPortalIdValid(portalId)) { return(tree); } } else { portalId = GetActivePortalId(); } var allFolders = GetPortalFolders(portalId, searchText, permission); var folders = allFolders.Select(f => new ItemDto { Key = f.FolderID.ToString(CultureInfo.InvariantCulture), Value = f.FolderName, HasChildren = false, Selectable = true }); tree.Children = ApplySort(folders, sortOrder).Select(dto => new NTree <ItemDto> { Data = dto }).ToList(); return(tree); }
private NTree <ItemDto> GetTreePathForPageInternal(string itemId, int sortOrder, bool includePortalTree = false, bool includeDisabled = false, bool includeAllTypes = false) { var tree = new NTree <ItemDto> { Data = new ItemDto { Key = RootKey } }; int itemIdAsInt; if (string.IsNullOrEmpty(itemId) || !int.TryParse(itemId, out itemIdAsInt)) { return(tree); } var portals = PortalController.GetPortalDictionary(); int portalId; if (portals.ContainsKey(itemIdAsInt)) { portalId = portals[itemIdAsInt]; } else { return(tree); } return(GetTreePathForPageInternal(portalId, itemIdAsInt, sortOrder, includePortalTree, includeDisabled, includeAllTypes)); }
public void Traverse(NTree <T> node, TreeVisitor <T> visitor, string t, ref NTree <T> r) { visitor(node.data, node, t, ref r); foreach (NTree <T> kid in node.children) { Traverse(kid, visitor, t, ref r); } }
public NTree <T> AddChild(T data) { var newNode = new NTree <T>(data); _children.AddFirst(newNode); return(newNode); }
public void Traverse(NTree <T> node, TreeVisitor <T> visitor) { visitor(node.data); foreach (NTree <T> kid in node.children) { Traverse(kid, visitor); } }
public void Traverse(NTree <T> node, TreeVisitor <T> visitor) { visitor(node.Data); foreach (NTree <T> child in node._children) { Traverse(child, visitor); } }
private bool AddToFrontier(NTree<PuzzleNode> nodeState) { if (!ClosedList.Contains(nodeState) || !Frontier.Contains(nodeState)) { Frontier.Enqueue(nodeState); return true; } return false; }
public void AddChild(T data) { var node = new NTree <T>(data) { Parent = this }; children.AddFirst(node); }
private NTree <string> MoveToChild(NTree <string> currentNode, string child) { if (currentNode.HasChild(child)) { return(currentNode.GetChild(child)); } return(currentNode.AddChild(child)); }
public void PlayWithTree() { NTree <int> tree = new NTree <int>(); // Initialize tree // If the tree has 47 nodes, WreakHavoc will be called 47 times, // once for each node in the tree. tree.traverse(WreakHavoc); }
public void NTree_Object_Default() { // Act var sut = new NTree <object>(); // Assert Assert.Equal(sut.Value, null); Assert.Equal(sut.ChildsList.Count, 0); Assert.False(sut.ChildsEnumerable.Any()); }
public void NTree_Object(object value) { // Act var sut = new NTree <object>(value); // Assert Assert.Equal(sut.Value, value); Assert.Equal(sut.ChildsList.Count, 0); Assert.False(sut.ChildsEnumerable.Any()); }
public static XElement TreeAsXml <T>(this NTree <T> node) { XElement element = new XElement("Node", new XAttribute("value", node.data)); foreach (var child in node.children) { element.Add(TreeAsXml(child)); } return(element); }
private NTree <ItemDto> SortFoldersInternal(int portalId, NTree <ItemIdDto> openedNodesTree, int sortOrder, string permissions) { var sortedTree = new NTree <ItemDto> { Data = new ItemDto { Key = RootKey } }; SortFoldersRecursevely(portalId, sortedTree, openedNodesTree, sortOrder, permissions); return(sortedTree); }
public void Equals_ObjectNull_Returns_False() { // Arrange object otherTree = null; var sut = new NTree <int>(); // Act var result = sut.Equals(otherTree); // Assert Assert.False(result); }
NTree <int> BuildTree() { var tree = new NTree <int>(0); tree.Add(1).Add(2).Add(3); tree.Children[0].Add(4).Add(5); tree.Children[0].Children[0].Add(6); tree.Children[1].Add(7); tree.Children[2].Add(8); tree.Children[2].Children[0].Add(9); return(tree); }
public override List <Puzzle> search(Puzzle puzzle) { NTree <Puzzle> tree = new NTree <Puzzle>(puzzle, repoPuzzle.construireTree(puzzle)); var allVisited = new List <Puzzle>(); Queue <Node <Puzzle> > q = new Queue <Node <Puzzle> >(); q.Enqueue(tree.root); while (q.Count() != 0) { Node <Puzzle> temp = q.Peek(); Node <Puzzle> node = null; int dife = 0; q.Dequeue(); // allVisited.Add(temp.Value); if (repoPuzzle.isGoal(temp.Value)) { return(allVisited); } NTree <Puzzle>[] noduri = repoPuzzle.construireTree(temp.Value); if (temp.ChildrensCount == 0 && noduri.Count() != 0) { if (noduri.Count() != 0) { NTree <Puzzle> temporar = new NTree <Puzzle>(temp.Value, noduri); temp.Childrens = temporar.root.Childrens; foreach (var el in temporar.root.Childrens) { int auxD = repoPuzzle.checkDiferences(el.Value); auxD = auxD + el.ChildrensCount; if (auxD > dife) { node = el; dife = auxD; } } if (node != null) { q.Enqueue(node); } } } // else { foreach (var va1 in temp.Childrens) { q.Enqueue(va1); } } } return(null); }
public void ByLevel_OneLevel() { // Arrange var value = 0; var sut = new NTree <int>(value); // Act var result = sut.ByLevel; // Assert Assert.True(result.SequenceEqual(new[] { value })); }
public void Dfs_GraphWith1Node_ReturnsNTreeWith1Node() { // Arrange var expectedResult = new NTree <int>(0); var countOfNodes = 1; var sut = GetGraph(countOfNodes); // Act var result = sut.Dfs(0); // Assert Assert.True(expectedResult.Equals(result)); }
public static bool CalculateNextNode (int NumSingleSheets, ref NTree<List<int>> Tree, double probability) { var savedNode = memory.Find(Tree.GetNode()); var found = savedNode != null; if (!found) { if (!Tree.IsLeaf) { var nodeProbability = (1.0 / double.Parse(Tree.GetNode().Count.ToString())); probability = probability * nodeProbability; for (var i = Tree.GetNode().Count - 1; i >= 0; i--) { var newTree = new NTree<List<int>>(Tree.GenerateNewNode(i)); CalculateNextNode(NumSingleSheets, ref newTree, probability); var k = 0; if (Tree.IsSolitary) { k = 1; } for (var j = 0; j <= 2; j++) { foreach (var element in newTree.probabilityNodeToleafPerSinglesSheets[j]) { Tree.probabilityNodeToleafPerSinglesSheets[j + k].Add(nodeProbability * element); } } } memory.Add(new MemoriaParaP151(Tree.GetNode(), Tree.probabilityNodeToleafPerSinglesSheets)); } else { Tree.probabilityNodeToleafPerSinglesSheets[0].Add(1.0); memory.Add(new MemoriaParaP151(Tree.GetNode(), Tree.probabilityNodeToleafPerSinglesSheets)); } } else { Tree.probabilityNodeToleafPerSinglesSheets = savedNode.probabilityNodeToleafPerSinglesSheets; } return found; }
private static NTree <ItemDto> GetPagesInPortalGroupInternal(int sortOrder) { var treeNode = new NTree <ItemDto> { Data = new ItemDto { Key = RootKey } }; var portals = GetPortalGroup(sortOrder); treeNode.Children = portals.Select(dto => new NTree <ItemDto> { Data = dto }).ToList(); return(treeNode); }
public TreeMenu GetSkillMenu() { var skillTree = new NTree(new Node("Get High", new GTASprite("mpinventory", "mp_specitem_weed"), NodeType.Skill), TreeType.Skill, new Point(50, 120)); skillTree.AddChild(new Node("Blazed Off Glory", new GTASprite("mpcarhud", "ocelot"), NodeType.Skill)) .AddChild(new Node("Reject Nonsense", new GTASprite("mpinventory", "mp_specitem_heroin"), NodeType.Skill)) .AddChild(new Node("Get Hammered", new GTASprite("mpinventory", "survival"), NodeType.Skill)); var toughen = skillTree.AddChild(new Node("Toughen Up", new GTASprite("mpinventory", "drug_trafficking"), NodeType.Skill)) .AddChild(new Node("Reinforcements", new GTASprite("mpinventory", "team_deathmatch"), NodeType.Skill)); toughen.AddChild(new Node("Rampage", new GTASprite("heisthud", "hc_trevor"), NodeType.Skill, TreeDirection.Down)); return(new TreeMenu(skillTree)); }
public void Equals_NTree1LevelSameValue_Returns_True() { // Arrange var value = 5; var otherTree = new NTree <int>(value); var sut = new NTree <int>(value); // Act var result = sut.Equals(otherTree); // Assert Assert.True(result); }
public void NTree_Object_WhithChilds(object value, string childsValues) { // Arrange var childs = childsValues.Split(' ') .Select(s => new NTree <object>(s)) .ToList(); // Act var sut = new NTree <object>(value, childs); // Assert Assert.Equal(sut.Value, value); Assert.Same(sut.ChildsList, childs); Assert.True(sut.ChildsEnumerable.SequenceEqual(childs)); }
public void Equals_NTree1LevelDifferentValue_Returns_False() { // Arrange var value1 = 5; var value2 = 50; var otherTree = new NTree <int>(value1); var sut = new NTree <int>(value2); // Act var result = sut.Equals(otherTree); // Assert Assert.False(result); }
/// <summary> /// Find the path to the partular node in the tree from the root node in the tree. /// Returns an array of 'Direction's. /// </summary> /// <param name="puzzle"></param> /// <returns></returns> public Direction[] PathToNode(NTree<PuzzleNode> puzzle) { Direction[] result; if (puzzle.Parent == null) //If this is the root node, there is no path! { result = new Direction[0]; return result; } else //Other wise, path to here is the path to parent // plus parent to here { Direction[] pathToParent = PathToNode(puzzle.Parent); result = new Direction[pathToParent.Length + 1]; for (int i = 0; i < pathToParent.Length; i++) { result[i] = pathToParent[i]; } result[result.Length - 1] = puzzle.Value.PathFromParent; return result; } }
public void NTreePushesEntities() { var objs = TestResourceFactory.GetMockClassAObjects(50).ToList(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); objs.ForEach(o => o.Id = seedIndex.Increment()); var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList(); using (var tree = new NTree<int, MockClassA, long>("Id", true)) { var ids = tree.AddOrUpdateRange(toAdd); tree.AddOrUpdate(toAdd.First()); Assert.AreEqual(50, tree.Length); Assert.AreEqual(5L, tree.GetFirstByIndex(5)); Assert.AreEqual(5, tree.GetFirstBySegment(5)); Assert.AreEqual(1, tree.GetByIndex(1).Count()); Assert.AreEqual(5, tree.GetFirstBySegment(5)); } }
private NTree<ItemDto> SortFoldersInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder, string permissions) { var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; SortFoldersRecursevely(portalId, sortedTree, openedNodesTree, sortOrder, permissions); return sortedTree; }
private NTree<ItemDto> GetFoldersInternal(int portalId, int sortOrder, string permissions) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; var children = ApplySort(GetFolderDescendantsInternal(portalId, -1, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); tree.Children = children; foreach (var child in tree.Children) { children = ApplySort(GetFolderDescendantsInternal(portalId, child.Data.Key, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); child.Children = children; } return tree; }
private NTree<ItemDto> GetTreePathForPageInternal(int portalId, int selectedItemId, int sortOrder, bool includePortalTree = false) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (selectedItemId <= 0) { return tree; } var pages = GetPortalPages(portalId); if (pages == null) { return tree; } var page = pages.SingleOrDefault(pageInfo => pageInfo.TabID == selectedItemId); if (page == null) { return tree; } var selfTree = new NTree<ItemDto> { Data = new ItemDto { Key = page.TabID.ToString(CultureInfo.InvariantCulture), Value = page.LocalizedTabName, HasChildren = page.HasChildren, Selectable = true } }; var parentId = page.ParentId; var parentTab = parentId > 0 ? pages.SingleOrDefault(t => t.TabID == parentId) : null; while (parentTab != null) { // load all sibiling var siblingTabs = GetChildrenOf(pages, parentId); siblingTabs = ApplySort(siblingTabs, sortOrder); var siblingTabsTree = siblingTabs.Select(t => new NTree<ItemDto> { Data = t }).ToList(); // attach the tree if (selfTree.Children != null) { foreach (var node in siblingTabsTree) { if (node.Data.Key == selfTree.Data.Key) { node.Children = selfTree.Children; break; } } } selfTree = new NTree<ItemDto> { Data = new ItemDto { Key = parentId.ToString(CultureInfo.InvariantCulture), Value = parentTab.LocalizedTabName, HasChildren = true, Selectable = true }, Children = siblingTabsTree }; parentId = parentTab.ParentId; parentTab = parentId > 0 ? pages.SingleOrDefault(t => t.TabID == parentId) : null; } // retain root pages var rootTabs = GetChildrenOf(pages, Null.NullInteger); rootTabs = ApplySort(rootTabs, sortOrder); var rootTree = rootTabs.Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); foreach (var node in rootTree) { if (node.Data.Key == selfTree.Data.Key) { node.Children = selfTree.Children; break; } } if (includePortalTree) { var myGroup = GetMyPortalGroup(); var portalTree = myGroup.Select( portal => new NTree<ItemDto> { Data = new ItemDto { Key = PortalPrefix + portal.PortalID.ToString(CultureInfo.InvariantCulture), Value = portal.PortalName, HasChildren = true, Selectable = false } }).ToList(); foreach (var node in portalTree) { if (node.Data.Key == PortalPrefix + portalId.ToString(CultureInfo.InvariantCulture)) { node.Children = rootTree; break; } } rootTree = portalTree; } tree.Children = rootTree; return tree; }
private NTree<ItemDto> GetTreePathForPageInternal(string itemId, int sortOrder, bool includePortalTree = false) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; int itemIdAsInt; if (string.IsNullOrEmpty(itemId) || !int.TryParse(itemId, out itemIdAsInt)) { return tree; } var portals = PortalController.GetPortalDictionary(); int portalId; if (portals.ContainsKey(itemIdAsInt)) { portalId = portals[itemIdAsInt]; } else { return tree; } return GetTreePathForPageInternal(portalId, itemIdAsInt, sortOrder, includePortalTree); }
private static void SortPagesRecursevely(IList<TabInfo> tabs, NTree<ItemDto> treeNode, NTree<ItemIdDto> openedNode, int sortOrder) { if (openedNode == null) { return; } var children = ApplySort(GetChildrenOf(tabs, openedNode.Data.Id), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); treeNode.Children = children; if (openedNode.HasChildren()) { foreach (var openedNodeChild in openedNode.Children) { var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, openedNodeChild.Data.Id, StringComparison.InvariantCultureIgnoreCase)); if (treeNodeChild == null) { continue; } SortPagesRecursevely(tabs, treeNodeChild, openedNodeChild, sortOrder); } } }
private NTree<ItemDto> SortPagesInPortalGroupInternal(NTree<ItemIdDto> openedNode, int sortOrder) { var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (openedNode == null) { return treeNode; } var portals = GetPortalGroup(sortOrder); treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); if (openedNode.HasChildren()) { foreach (var openedNodeChild in openedNode.Children) { var portalIdString = openedNodeChild.Data.Id; var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, portalIdString, StringComparison.InvariantCultureIgnoreCase)); if (treeNodeChild == null) { continue; } int portalId; if (!int.TryParse(portalIdString.Replace(PortalPrefix, string.Empty), out portalId)) { portalId = -1; } var treeOfPages = SortPagesInternal(portalId, openedNodeChild, sortOrder); treeNodeChild.Children = treeOfPages.Children; } } return treeNode; }
private NTree<ItemDto> GetPagesInternal(int portalId, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false) { if (portalId == -1) { portalId = GetActivePortalId(); } var tabs = GetPortalPages(portalId, includeDisabled, includeAllTypes); var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (tabs == null) { return sortedTree; } var children = ApplySort(GetChildrenOf(tabs, Null.NullInteger), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); sortedTree.Children = children; return sortedTree; }
private NTree<ItemDto> GetTreePathForFolderInternal(string selectedItemId, int sortOrder, string permission) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; int itemId; if (string.IsNullOrEmpty(selectedItemId) || !int.TryParse(selectedItemId, out itemId)) { return tree; } if (itemId <= 0) { return tree; } var folder = FolderManager.Instance.GetFolder(itemId); if (folder == null) { return tree; } var hasPermission = string.IsNullOrEmpty(permission) ? (HasPermission(folder, "BROWSE") || HasPermission(folder, "READ")) : HasPermission(folder, permission.ToUpper()); if (!hasPermission) return new NTree<ItemDto>(); var selfTree = new NTree<ItemDto> { Data = new ItemDto { Key = folder.FolderID.ToString(CultureInfo.InvariantCulture), Value = folder.FolderName, HasChildren = HasChildren(folder, permission), Selectable = true } }; var parentId = folder.ParentID; var parentFolder = parentId > 0 ? FolderManager.Instance.GetFolder(parentId) : null; while (parentFolder != null) { // load all sibling var siblingFolders = GetFolderDescendants(parentFolder, string.Empty, permission) .Select(folderInfo => new ItemDto { Key = folderInfo.FolderID.ToString(CultureInfo.InvariantCulture), Value = folderInfo.FolderName, HasChildren = HasChildren(folderInfo, permission), Selectable = true }).ToList(); siblingFolders = ApplySort(siblingFolders, sortOrder).ToList(); var siblingFoldersTree = siblingFolders.Select(f => new NTree<ItemDto> { Data = f }).ToList(); // attach the tree if (selfTree.Children != null) { foreach (var node in siblingFoldersTree) { if (node.Data.Key == selfTree.Data.Key) { node.Children = selfTree.Children; break; } } } selfTree = new NTree<ItemDto> { Data = new ItemDto { Key = parentId.ToString(CultureInfo.InvariantCulture), Value = parentFolder.FolderName, HasChildren = true, Selectable = true }, Children = siblingFoldersTree }; parentId = parentFolder.ParentID; parentFolder = parentId > 0 ? FolderManager.Instance.GetFolder(parentId) : null; } selfTree.Data.Value = SharedConstants.RootFolder; tree.Children.Add(selfTree); return tree; }
public abstract Direction[] Solve(NTree<PuzzleNode> aPuzzle);
private static NTree<ItemDto> GetPagesInPortalGroupInternal(int sortOrder) { var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; var portals = GetPortalGroup(sortOrder); treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); return treeNode; }
private NTree<ItemDto> GetPagesInternal(int portalId, int sortOrder) { var tabs = GetPortalPages(portalId); var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (tabs == null) { return sortedTree; } var children = ApplySort(GetChildrenOf(tabs, Null.NullInteger), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); sortedTree.Children = children; return sortedTree; }
private NTree<ItemDto> SortPagesInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false) { var pages = GetPortalPages(portalId, includeDisabled, includeAllTypes); var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (pages == null) { return sortedTree; } SortPagesRecursevely(pages, sortedTree, openedNodesTree, sortOrder); return sortedTree; }
private void SortFoldersRecursevely(int portalId, NTree<ItemDto> treeNode, NTree<ItemIdDto> openedNode, int sortOrder, string permissions) { if (openedNode == null) { return; } var children = ApplySort(GetFolderDescendantsInternal(portalId, openedNode.Data.Id, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); treeNode.Children = children; if (openedNode.HasChildren()) { foreach (var openedNodeChild in openedNode.Children) { var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, openedNodeChild.Data.Id, StringComparison.InvariantCultureIgnoreCase)); if (treeNodeChild == null) { continue; } SortFoldersRecursevely(portalId, treeNodeChild, openedNodeChild, sortOrder, permissions); } } }
private NTree<ItemDto> SearchPagesInternal(int portalId, string searchText, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false, bool includeActive = true, bool includeHostPages = false) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; List<TabInfo> tabs; if (portalId == -1) { portalId = GetActivePortalId(); } else { if (!IsPortalIdValid(portalId)) { return tree; } } Func<TabInfo, bool> searchFunc; if (String.IsNullOrEmpty(searchText)) { searchFunc = page => true; } else { searchFunc = page => page.LocalizedTabName.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) > -1; } if (portalId > -1) { var includeHiddenTabs = PortalSettings.UserInfo.IsSuperUser || PortalSettings.UserInfo.IsInRole("Administrators"); tabs = TabController.Instance.GetTabsByPortal(portalId).Where(tab => (includeActive || tab.Value.TabID != PortalSettings.ActiveTab.TabID) && (includeHiddenTabs || tab.Value.IsVisible) && (includeDisabled || !tab.Value.DisableLink) && (includeAllTypes || tab.Value.TabType == TabType.Normal) && searchFunc(tab.Value)) .OrderBy(tab => tab.Value.TabOrder) .Select(tab => tab.Value) .ToList(); if (PortalSettings.UserInfo.IsSuperUser && includeHostPages) { tabs.AddRange(TabController.Instance.GetTabsByPortal(-1).Where(tab => !tab.Value.DisableLink && searchFunc(tab.Value)) .OrderBy(tab => tab.Value.TabOrder) .Select(tab => tab.Value) .ToList()); } } else { if (PortalSettings.UserInfo.IsSuperUser) { tabs = TabController.Instance.GetTabsByPortal(-1).Where(tab => !tab.Value.DisableLink && searchFunc(tab.Value)) .OrderBy(tab => tab.Value.TabOrder) .Select(tab => tab.Value) .ToList(); } else { return tree; } } var pages = tabs.Select(tab => new ItemDto { Key = tab.TabID.ToString(CultureInfo.InvariantCulture), Value = tab.LocalizedTabName, HasChildren = false, Selectable = true }); tree.Children = ApplySort(pages, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); return tree; }
private NTree<ItemDto> SearchFoldersInternal(int portalId, string searchText, int sortOrder, string permission) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (portalId > -1) { if (!IsPortalIdValid(portalId)) { return tree; } } else { portalId = PortalSettings.PortalId; } var allFolders = GetPortalFolders(portalId, searchText, permission); var folders = allFolders.Select(f => new ItemDto { Key = f.FolderID.ToString(CultureInfo.InvariantCulture), Value = f.FolderName, HasChildren = false, Selectable = true }); tree.Children = ApplySort(folders, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); return tree; }
private NTree<ItemDto> SortFilesInternal(int portalId, int parentId, string filter, int sortOrder, string permissions) { var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; var children = GetFileItemsDto(portalId, parentId, filter, string.Empty, permissions, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); sortedTree.Children = children; return sortedTree; }
public void NTreeReturnsEmptyPageWithWrongPageId() { var objs = TestResourceFactory.GetMockClassAObjects(50).ToList(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); objs.ForEach(o => o.Id = seedIndex.Increment()); var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList(); using (var tree = new NTree<int, MockClassA, long>("Id", true)) { var ids = tree.AddOrUpdateRange(toAdd); tree.AddOrUpdate(toAdd.First()); Assert.AreEqual(50, tree.Length); var p = tree.GetPage(8); Assert.AreEqual(0, p.Length); } }
private NTree<ItemDto> SearchPagesInPortalGroupInternal(string searchText, int sortOrder) { var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; var portals = GetPortalGroup(sortOrder); treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); foreach (var child in treeNode.Children) { int portalId; if (int.TryParse(child.Data.Key.Replace(PortalPrefix, string.Empty), out portalId)) { var pageTree = SearchPagesInternal(portalId, searchText, sortOrder); child.Children = pageTree.Children; } } return treeNode; }
/// <summary> /// Starts the arbitrage /// </summary> /// <param name="originalAmount"></param> /// <param name="targetCurrency"></param> /// <param name="frequencyInSec"></param> /// <param name="profitThreshold"></param> /// <param name="realTrading"></param> /// <param name="allowedPairs"></param> public void Start(decimal originalAmount, string targetCurrency, int frequencyInSec, decimal profitThreshold, bool realTrading, BtcePair[] allowedPairs) { realTrading = false; //!!!DO not use real trading _allowedPairs = allowedPairs; _pairsAsString = _allowedPairs.Select(p => BtcePairHelper.ToString(p)).ToArray(); _mustStop = false; OnReportProgress("Starting Arbitrage - Monitoring opportunities..."); while (!_mustStop) { Dictionary<BtcePair, Ticker> tickers; try { tickers = BtceApiV3.GetTicker(_allowedPairs); } catch (Exception ex) { Logger.Log(ex); OnReportProgress("Error: " + ex.ToString()); System.Threading.Thread.Sleep(1000 * frequencyInSec); continue; } var pairs = _allowedPairs.Where(p => p.HasCurrency(targetCurrency)); var ac = new MyAction { UnitsCurrency1 = 0, UnitsCurrency2 = originalAmount, Pair = BtcePair.Unknown }; NTree<MyAction> tree = new NTree<MyAction>(ac); foreach (var p in pairs) { BuildArbitrageTree(tickers, p, tree, originalAmount, p.Item1() == targetCurrency, targetCurrency); } var leaves = new List<NTree<MyAction>>(); tree.Traverse(n => { if (n.Data.IsFinalAction) { leaves.Add(n); } }); decimal maxProfit = 0; List<NTree<MyAction>> bestChain = null; int bestIndex = 0; for (var lIndex = 0; lIndex < leaves.Count; lIndex++) { // System.Diagnostics.Debug.WriteLine("Option " + (lIndex + 1)); var l = leaves[lIndex]; var t = l.GetTree(); for (var nIndex = 1; nIndex < t.Count; nIndex++) { var c = t[nIndex].Data; //System.Diagnostics.Debug.WriteLine(string.Format("Converting {0:0.00###} {1:0.00###} to {2:0.00###} {3:0.00###}", c.UnitsCurrency1, c.Currency1, c.UnitsCurrency2, c.Currency2)); } decimal profit = l.Data.UnitsCurrency2 - originalAmount; // System.Diagnostics.Debug.WriteLine("Profit " + profit.ToString("0.00###")); if (profit > maxProfit) { maxProfit = l.Data.UnitsCurrency2 - originalAmount; bestChain = t; bestIndex = lIndex; } } if (bestChain != null) { //System.Diagnostics.Debug.WriteLine("Best Option: " + (bestIndex + 1)); OnReportProgress("Max profit: " + maxProfit.ToString("0.00###")); for (var nIndex = 1; nIndex < bestChain.Count; nIndex++) { var c = bestChain[nIndex].Data; OnReportProgress(c.Description); } _currentChain = bestChain; var percentage = maxProfit / originalAmount * 100; OnReportProgress(string.Format("Percentage {0:0.00}", percentage)); if (percentage > profitThreshold) { FollowChain(bestChain, realTrading); } } else { System.Diagnostics.Debug.WriteLine("No profit possible"); } System.Diagnostics.Debug.WriteLine("======================================================================="); System.Threading.Thread.Sleep(1000 * frequencyInSec); } }
private NTree<ItemDto> SearchPagesInPortalGroupInternal(string treeAsJson, string searchText, int sortOrder) { var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; var openedNode = Json.Deserialize<NTree<ItemIdDto>>(treeAsJson); if (openedNode == null) { return treeNode; } var portals = GetPortalGroup(sortOrder); treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); if (!openedNode.HasChildren()) { return treeNode; } foreach (var openedNodeChild in openedNode.Children) { var portalIdString = openedNodeChild.Data.Id; var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, portalIdString, StringComparison.InvariantCultureIgnoreCase)); if (treeNodeChild == null) { continue; } int portalId; if (int.TryParse(treeNodeChild.Data.Key.Replace(PortalPrefix, string.Empty), out portalId)) { var pageTree = SearchPagesInternal(portalId, searchText, sortOrder); treeNodeChild.Children = pageTree.Children; } } return treeNode; }
private NTree<ItemDto> SearchPagesInternal(int portalId, string searchText, int sortOrder) { var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; List<TabInfo> tabs; if (portalId == -1) { portalId = GetActivePortalId(); } else { if (!IsPortalIdValid(portalId)) { return tree; } } Func<TabInfo, bool> searchFunc; if (String.IsNullOrEmpty(searchText)) { searchFunc = page => true; } else { searchFunc = page => page.LocalizedTabName.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) > -1; } var tabController = new TabController(); var allTabs = tabController.GetAllTabs().ToArray().Select(tab => (TabInfo)tab).ToList(); if (portalId > -1) { var includeHiddenTabs = PortalSettings.UserInfo.IsSuperUser || PortalSettings.UserInfo.IsInRole("Administrators"); if (!includeHiddenTabs) allTabs = allTabs.Where(t => t.IsVisible).ToList(); tabs = allTabs.Where(tab => tab.PortalID == portalId && !tab.DisableLink && searchFunc(tab)) .OrderBy(tab => tab.TabOrder) .ToList(); } else { if (PortalSettings.UserInfo.IsSuperUser) { tabs = allTabs.Where(tab => tab.PortalID == -1 && !tab.DisableLink && searchFunc(tab)) .OrderBy(tab => tab.TabOrder) .ToList(); } else { return tree; } } var pages = tabs.Select(tab => new ItemDto { Key = tab.TabID.ToString(CultureInfo.InvariantCulture), Value = tab.LocalizedTabName, HasChildren = false, Selectable = true }); tree.Children = ApplySort(pages, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList(); return tree; }
/// <summary> /// /// </summary> /// <param name="graph"></param> /// <param name="k">number of intervals</param> /// <returns></returns> public IEnumerable<int> ExonChaining(NTree<string> graph, int k) { return null; }
private NTree<ItemDto> SortPagesInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder) { var pages = GetPortalPages(portalId); var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } }; if (pages == null) { return sortedTree; } SortPagesRecursevely(pages, sortedTree, openedNodesTree, sortOrder); return sortedTree; }
public void NTreePushesLotsOfDuplicateEntities() { var objs = TestResourceFactory.GetMockClassAObjects(20480).ToList(); var seedIndex = new Seed32(); var seedSegment = new Seed64(); objs.ForEach(o => o.Id = seedIndex.Increment()); var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList(); using (var tree = new NTree<int, MockClassA, long>("Id", true)) { var ids = tree.AddOrUpdateRange(toAdd); Assert.AreEqual(20480, tree.Length); Assert.AreEqual(5, tree.GetFirstByIndex(5)); Assert.AreEqual(5, tree.GetFirstBySegment(5)); Assert.AreEqual(1, tree.GetByIndex(5).Count()); tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment())); Assert.AreEqual(20481, tree.Length); tree.AddOrUpdateRange(toAdd.Skip(100).Take(100).ToList()); Assert.AreEqual(20481, tree.Length); } }