public void OnEnable() { if (map == null) { map = new NodeDictionary(); } }
protected override void GenerateTree(object obj) { NewReleaseItem newReleaseItem = (NewReleaseItem) obj; NewReleaseHierarchyNode root = new NewReleaseHierarchyNode(newReleaseItem, this); RootNodes.Add(root); NodeDictionary.Add(root.NewReleaseItem.Album.Name, root); }
public void Set(string key, Node value) { if (_source != null) { _buckets = new Bucket[Capacity]; for (var i = 0; i < Capacity; i++) { var sourceBucket = _source._buckets[i]; if (sourceBucket != null) { _buckets[i] = new Bucket(sourceBucket); } } _source = null; } var hashCode = key.GetHashCode() & 0x7FFFFFFF; var index = hashCode % Capacity; var bucket = _buckets[index]; if (bucket == null) { bucket = new Bucket(); _buckets[index] = bucket; } if (bucket.Set(key, value)) { _size++; } }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <returns>Returns whether the sub-tree has been fully expanded in the hierarchy.</returns> public override void GenerateSubTree(IHierarchyNode node) { ArtistHierarchyNode subTreeNode = (ArtistHierarchyNode)node; ArtistGroup relatedArtistList = Client.GetRelatedArtists(subTreeNode.ArtistViewModel.Artist.ID); //First determine which artists are new; add those. int nodesAdded = 0; foreach (Artist relatedArtist in relatedArtistList.Artists) { if (NodeDictionary.ContainsKey(relatedArtist.Name)) { continue; } if (nodesAdded < AddChildrenLimit) { ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist); ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, subTreeNode, subTreeNode.Level + 1); subTreeNode.Children.Add(relatedArtistNode); NodeDictionary.Add(relatedArtist.Name, relatedArtistNode); nodesAdded++; } else { return; } } }
public bool TryAddNode(Node node) { if (NodeDictionary.ContainsKey(node.ID) == false) { Nodes.Add(node); NodeDictionary.Add(node.ID, node); return(true); } return(false); }
public bool TryRemoveNode(Node node) { if (NodeDictionary.ContainsKey(node.ID)) { Nodes.Remove(node); NodeDictionary.Remove(node.ID); return(true); } return(false); }
void BuildNodeDictionary() { NodeDictionary.Clear(); foreach (var node in Nodes) { if (NodeDictionary.ContainsKey(node.ID) == false) { NodeDictionary.Add(node.ID, node); } } }
/// <summary> /// Collects the current key's object and all objects that depend on the current key into an ever-growing HashSet. /// </summary> /// <param name="objKey">Fetch the node associated with this object.</param> /// <param name="objReturn">HashSet containing all keys that depend on <paramref name="objKey"/> in some way. It's a HashSet to prevent infinite loops in case of cycles</param> private void CollectDependents(T objKey, HashSet <T> objReturn) { if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T> objLoopNode)) { if (objReturn.Add(objLoopNode.MyObject)) { foreach (DependencyGraphNode <T> objDependant in objLoopNode.UpStreamNodes.Where(x => x.DependencyCondition?.Invoke() != false).Select(x => x.Node)) { CollectDependents(objDependant.MyObject, objReturn); } } } }
/// <summary> /// Collects the current key's object and all objects that depend on the current key into an ever-growing HashSet. /// </summary> /// <param name="objParentInstance">Instance of the object whose dependencies are being processed, used for conditions.</param> /// <param name="objKey">Fetch the node associated with this object.</param> /// <param name="objReturn">Collection containing all keys that depend on <paramref name="objKey"/> in some way. It's a HashSet to prevent infinite loops in case of cycles</param> protected void CollectDependents(T2 objParentInstance, T objKey, ICollection <T> objReturn) { if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T, T2> objLoopNode) && !objReturn.Contains(objLoopNode.MyObject)) { objReturn.Add(objLoopNode.MyObject); foreach (DependencyGraphNodeWithCondition <T, T2> objNode in objLoopNode.UpStreamNodes) { if (objNode.DependencyCondition?.Invoke(objParentInstance) != false) { CollectDependents(objParentInstance, objNode.Node.MyObject, objReturn); } } } }
protected virtual SiteMapNode CreateNodeFromElement(XElement element, int currentLevel) { var attributes = new NameValueCollection(); foreach (var a in element.Attributes()) { attributes.Add(a.Name.ToString(), a.Value); } string uri; try { if (element.Attribute("uri") != null) { uri = element.Attribute("uri").Value; } else if (element.Attribute("pageId") != null) { uri = element.Attribute("pageId").Value; } else { uri = ""; } } catch { _logger.Debug("exception while retrieving uri", LoggingCategory.General); uri = ""; } SiteMapNode childNode = new TridionSiteMapNode(this, element.Attribute("id").Value, //key uri, element.Attribute("url").Value, //url element.Attribute("title").Value, //title element.Attribute("description").Value, //description null, //roles attributes, //attributes null, //explicitresourceKeys null) { Level = currentLevel }; // implicitresourceKey NodeDictionary.Add(childNode.Key, childNode); return(childNode); }
/// <summary> /// Returns an enumerable containing the current key's object and all objects that depend on the current key. /// Warning: DependencyGraphs with any cycles will cause this method to never terminate! /// </summary> /// <param name="objKey">Fetch the node associated with this object.</param> public IEnumerable <T> GetWithAllDependentsUnsafe(T objKey) { if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T> objLoopNode)) { yield return(objLoopNode.MyObject); foreach (DependencyGraphNode <T> objDependant in objLoopNode.UpStreamNodes.Where(x => x.DependencyCondition?.Invoke() != false).Select(x => x.Node)) { foreach (T objDependantObject in GetWithAllDependentsUnsafe(objDependant.MyObject)) { yield return(objDependantObject); } } } }
public Boolean Add([CanBeNull] T item) { if (item is null) { return(false); } if (NodeDictionary.ContainsKey(item)) { return(false); } LinkedListNode <T> node = LinkedList.AddLast(item); NodeDictionary.Add(item, node); return(true); }
/// <summary> /// Generates the tree from the root artist. /// </summary> /// <param name="artist"></param> protected override void GenerateTree(object obj) { Artist artist = (Artist)obj; if (NodeDictionary.ContainsKey(artist.Name)) { return; } ArtistViewModel rootViewModel = new ArtistViewModel(artist); ArtistHierarchyNode root = new ArtistHierarchyNode(rootViewModel, this, null, 0); RootNodes.Add(root); NodeDictionary.Add(artist.Name, root); ArtistGroup relatedArtistList = Client.GetRelatedArtists(artist.ID); //First determine which artists are new; add those. List <Artist> newArtists = new List <Artist>(); int nodesAdded = 0; foreach (Artist relatedArtist in relatedArtistList.Artists) { if (NodeDictionary.ContainsKey(relatedArtist.Name)) { continue; } if (nodesAdded < AddChildrenLimit) { newArtists.Add(relatedArtist); ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist); ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, root, 1); root.Children.Add(relatedArtistNode); NodeDictionary.Add(relatedArtist.Name, relatedArtistNode); nodesAdded++; } else { break; } } }
/// <summary> /// Returns an enumerable containing the current key's object and all objects that depend on the current key. /// Warning: DependencyGraphs with any cycles will cause this method to never terminate! /// </summary> /// <param name="objParentInstance">Instance of the object whose dependencies are being processed, used for conditions.</param> /// <param name="objKey">Fetch the node associated with this object.</param> public IEnumerable <T> GetWithAllDependentsUnsafe(T2 objParentInstance, T objKey) { if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T, T2> objLoopNode)) { yield return(objLoopNode.MyObject); foreach (DependencyGraphNodeWithCondition <T, T2> objNode in objLoopNode.UpStreamNodes) { if (objNode.DependencyCondition?.Invoke(objParentInstance) != false) { foreach (T objDependantObject in GetWithAllDependentsUnsafe(objParentInstance, objNode.Node.MyObject)) { yield return(objDependantObject); } } } } }
/// <summary> /// remove node from the net /// </summary> /// <param name="datas"></param> public void RemoveNodes(params Node[] datas) { if (datas.Length == 0) { nodes = new NodeDictionary(); removedIDs = new List <int>(); uniqueID = 1; return; } foreach (var node in datas) { if (nodes.ContainsKey(node.id)) { // disconnect all the neighbors foreach (var neighborID in node.neighbors) { var neighborNode = GetNode(neighborID); if (neighborNode != null && neighborNode.neighbors.Contains(node.id)) { neighborNode.neighbors.Remove(node.id); } } //reset downstream connection foreach (var nodeID in node.downstreams) //TODO move to neighbor check { var checkNode = GetNode(nodeID); if (checkNode != null && checkNode.downstreams != null && checkNode.downstreams.Contains(node.id)) { checkNode.downstreams.Remove(node.id); } } //Recycle ID if (!removedIDs.Contains(node.id)) { removedIDs.Add(node.id); } //Remove node nodes.Remove(node.id); } } }
private void Assert_AreDAGs(DirectedGraphContext[] directed_graphs_in_json, bool invert = false) { foreach (var expected in directed_graphs_in_json) { var dag = new DirectedAcyclicGraph <Node>(expected.Json); expected.Roots.Assert_NoDifferences(dag.Template.Roots); expected.Sinks.Assert_NoDifferences(dag.Template.Sinks); Assert.IsTrue(dag.Template.IsDirectedAcyclicGraph ^ invert); if (!string.IsNullOrEmpty(expected.NodeRelations)) { var nodes = new NodeDictionary(expected.NodeRelations); foreach (var n in nodes.ToArray()) { dag[n.Key]._children.Select(x => x.variable).ToArray().Assert_NoDifferences(n.Value["children"]); dag[n.Key]._parents.Select(x => x.variable).ToArray().Assert_NoDifferences(n.Value["parents"]); dag.Remove(n.Key); } Assert.IsTrue(dag.Count == 0); } } }
/// <summary> /// Returns a collection containing the current key's object and all objects that depend on the current key. /// Slower but idiot-proof compared to GetWithAllDependentsUnsafe(). /// </summary> /// <param name="objKey">Fetch the node associated with this object.</param> public ICollection <T> GetWithAllDependents(T objKey) { HashSet <T> objReturn = new HashSet <T>(); if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T> objLoopNode)) { if (objReturn.Add(objLoopNode.MyObject)) { foreach (DependencyGraphNode <T> objDependant in objLoopNode.UpStreamNodes.Where(x => x.DependencyCondition?.Invoke() != false).Select(x => x.Node)) { CollectDependents(objDependant.MyObject, objReturn); } } } else { objReturn.Add(objKey); } return(objReturn); }
private void AddToHistory(Node previousNode, Node currentCandidateNode) { if (previousNode == currentCandidateNode) { return; } // Add node to dictionary first NodeDictionary.Add(previousNode.Id, previousNode); if (NodeHistory.ContainsKey(previousNode.Id)) { NodeHistory[previousNode.Id].Add(currentCandidateNode.Id); } else { NodeHistory[previousNode.Id] = new List <string>(); } NodeHistory[previousNode.Id].Add(currentCandidateNode.Id); }
public Boolean Insert(Int32 index, T?item) { if (index < 0 || index >= Count) { throw new ArgumentNullException(nameof(index)); } if (item is null) { return(false); } if (NodeDictionary.ContainsKey(item)) { return(false); } LinkedListNode <T> node = LinkedList.Insert(index, item); NodeDictionary.Add(item, node); return(true); }
public void TestOscilattors() { var oscillators = new OscilattorContext[] { new OscilattorContext { Object = new Oscillator <Node>(), Loops = new string[] { "A", "B" }, NodeRelations = "{'A':{'children':['B'],'parents':['B']},'B':{'children':['A'],'parents':['A']}}" }, new OscilattorContext { Object = new Oscillator <Node>("{'A':['B'],'B':['A'],'C':['A']}"), Loops = new string[] { "A", "B" }, NodeRelations = "{'A':{'children':['B'],'parents':['B','C']},'B':{'children':['A'],'parents':['A']},'C':{'children':['A'],'parents':[]}}" }, new OscilattorContext { Object = new Oscillator <Node>("{'A':['B','C'],'B':['A']}"), Loops = new string[] { "A", "B" }, NodeRelations = "{'A':{'children':['B','C'],'parents':['B']},'B':{'children':['A'],'parents':['A']},'C':{'children':[],'parents':['A']}}" } }; foreach (var expected in oscillators) { //{string:[string]} directed graph testing i.e. compact serialization form. expected.Loops.Assert_NoDifferences(expected.Object.Loops.Select(x => x.Key).ToArray()); expected.Loops.Assert_NoDifferences(expected.Object.Loops.SelectMany(x => x.Value).Distinct().ToArray()); //{string:{string:[string]}} directed graph testing i.e. independent element form. var nodes = new NodeDictionary(expected.NodeRelations); foreach (var n in nodes.ToArray()) { expected.Object.Graph[n.Key]._children.Select(x => x.variable).ToArray().Assert_NoDifferences(n.Value["children"]); expected.Object.Graph[n.Key]._parents.Select(x => x.variable).ToArray().Assert_NoDifferences(n.Value["parents"]); expected.Object.Graph.Remove(n.Key); } Assert.IsTrue(expected.Object.Graph.Count == 0); } }
public static NodeStatus Run(Node node, NodeDictionary nodeDictionary) { NodeState nodeState; if (!nodeDictionary.ContainsKey(node)) { nodeState = new Dictionary <string, object>(); node.OnInitialize(nodeDictionary, nodeState); nodeDictionary[node] = nodeState; } else { nodeState = nodeDictionary[node]; } var status = node.OnTick(nodeDictionary, nodeState); if (status == NodeStatus.Success) { node.OnSuccess(nodeDictionary, nodeState); } return(status); }
/// <summary> /// Returns a collection containing the current key's object and all objects that depend on the current key. /// Slower but idiot-proof compared to GetWithAllDependentsUnsafe(). /// </summary> /// <param name="objParentInstance">Instance of the object whose dependencies are being processed, used for conditions.</param> /// <param name="objKey">Fetch the node associated with this object.</param> public HashSet <T> GetWithAllDependents(T2 objParentInstance, T objKey) { HashSet <T> objReturn = new HashSet <T>(); if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <T, T2> objLoopNode)) { if (objReturn.Add(objLoopNode.MyObject)) { foreach (DependencyGraphNodeWithCondition <T, T2> objNode in objLoopNode.UpStreamNodes) { if (objNode.DependencyCondition?.Invoke(objParentInstance) != false) { CollectDependents(objParentInstance, objNode.Node.MyObject, objReturn); } } } } else { objReturn.Add(objKey); } return(objReturn); }
/// <summary> /// Returns a collection containing the current key's object and all objects that depend on the current key. /// Slower but idiot-proof compared to GetWithAllDependentsUnsafe(). /// </summary> /// <param name="objParentInstance">Instance of the object whose dependencies are being processed, used for conditions.</param> /// <param name="objKey">Fetch the node associated with this object.</param> /// <param name="blnUsePool">Whether to fetch the returned HashSet{string} from a pool or to just create a new one on the stack.</param> public HashSet <string> GetWithAllDependents(T objParentInstance, string objKey, bool blnUsePool) { HashSet <string> setReturn = blnUsePool ? Utils.StringHashSetPool.Get() : new HashSet <string>(); if (NodeDictionary.TryGetValue(objKey, out DependencyGraphNode <string, T> objLoopNode)) { if (setReturn.Add(objLoopNode.MyObject)) { foreach (DependencyGraphNodeWithCondition <string, T> objNode in objLoopNode.UpStreamNodes) { if (objNode.DependencyCondition?.Invoke(objParentInstance) != false) { CollectDependents(objParentInstance, objNode.Node.MyObject, setReturn); } } } } else { setReturn.Add(objKey); } return(setReturn); }
public NodeDictionary(NodeDictionary source) { _buckets = source._buckets; _size = source._size; _source = source; }
public DBlockNode() { _Children = new NodeDictionary(this); }
public bool TryGetNode(string id, out Node node) { return(NodeDictionary.TryGetValue(id, out node)); }
public Node(IIndexable owner, Node source) { Owner = owner; ChildNodes = new NodeDictionary(source.ChildNodes); Items = new List <TItem>(source.Items); }
public void BuildGraph() { PropertyDictionary = new PropertyDictionary(); foreach (var property in Properties) { PropertyDictionary.Add(property.Guid, property); } NodeDictionary = new NodeDictionary(); foreach (var node in Nodes) { NodeDictionary.Add(node.Guid, node); } // Link node lines with actual properties, find previous node and actor node where necessary var propertyNodes = Nodes.Where(node => node.Type == NodeType.PROP).ToDictionary(node => node.Guid, node => node); // convert each conversation line reference from port to property lists using edge list foreach (var node in Nodes) { if (node.Type != NodeType.SELF && node.Type != NodeType.NPC) { continue; } foreach (var line in node.Lines) { line.Checks = new List <string>(); line.Triggers = new List <string>(); string setNext = null; foreach (var edge in Edges) { // Find triggers if (line.TriggerPort == edge.FromPort) { var nodeGuid = edge.ToNode; line.Triggers.Add(propertyNodes[nodeGuid].Temp_PropertyNodeGuid); } // Find checks, only for NPC nodes if (node.Type == NodeType.NPC && line.CheckPort == edge.ToPort && NodeDictionary[edge.FromNode].Type == NodeType.PROP) { var nodeGuid = edge.FromNode; line.Checks.Add(propertyNodes[nodeGuid].Temp_PropertyNodeGuid); } // Find next node if (edge.FromNode == node.Guid && line.Next == edge.FromPort) { setNext = edge.ToNode; } } line.Next = setNext; } foreach (var edge in Edges) { // Find actor node if (edge.ToNode == node.Guid && node.Type == NodeType.NPC && propertyNodes.ContainsKey(edge.FromNode) && PropertyDictionary[propertyNodes[edge.FromNode].Temp_PropertyNodeGuid].Type == PropertyType.Actor) { node.ActorGuid = propertyNodes[edge.FromNode].Temp_PropertyNodeGuid; } // Find previous node if (edge.ToNode == node.Guid && (NodeDictionary[edge.FromNode].Type == NodeType.NPC || NodeDictionary[edge.FromNode].Type == NodeType.SELF)) { node.Previous = edge.FromNode; } } } // Remove property nodes from Nodes and NodeDictionary var copyOfNodes = Nodes.ToList(); copyOfNodes.ForEach(node => { if (node.Type == NodeType.NPC || node.Type == NodeType.SELF) { return; } NodeDictionary.Remove(node.Guid); Nodes.Remove(node); }); // Find start node foreach (var node in Nodes) { if (!string.IsNullOrEmpty(node.Previous)) { continue; } if (!string.IsNullOrEmpty(StartNode) && StartNode != node.Guid) { Debug.LogWarning("Multiple nodes without a previous node detected! Defaulting to the first one found to be the start node."); continue; } StartNode = node.Guid; } }
public Net(Node[] data) { nodes = new NodeDictionary(); AddNodes(data); }
public bool HasNode(string id) { return(NodeDictionary.ContainsKey(id)); }
public DMethod() { children = new NodeDictionary(this); }
public Net() { nodes = new NodeDictionary(); }