static IEnumerable<DependencyNode<ContributorNotification>> GetCompatibleTypes(DependencyTree<ContributorNotification> tree, DependencyNode<ContributorNotification> notificationNode, IEnumerable<Type> beforeTypes) { return from childType in beforeTypes from compatibleNode in tree.Nodes where compatibleNode != notificationNode && childType.IsAssignableFrom(compatibleNode.Value.Contributor.GetType()) select compatibleNode; }
protected override void Init() { base.Init(); changeCounter = 0; addressDependency = DependencyNode.Create(() => Student.School.Address); addressDependency.DependencyChanged += (node, e) => changeCounter++; //reset the base class dependency (not used here) ResetDependency(); }
public ParentChildItem(string name) { Name = name; var pts = DependencyNode.Create(() => Parent.Child.Name); pts.DependencyChanged += OnParentDependencyChanged; parentToSelfDependency = pts; var cts = DependencyNode.Create(() => Child.Parent.Name); cts.DependencyChanged += OnChildDependencyChanged; childToSelfDependency = cts; }
public void Sub_Property_Tracking_Can_Be_Disabled_Through_Settings() { //create settings class var settings = new DependencyNodeSettings<IAddress>(() => Student.School.Address); //configure settings to ignore sub item changes settings.ObserveSubValueChanges = false; //dispose old dependency in order to get rid of event listener! addressDependency.Dispose(); addressDependency = DependencyBuilder.CreateDependency(settings); //does not cause a change event: Student.School.Address.City = "Ethon"; Assert.AreEqual(0, changeCounter); }
public void Disabling_Collection_Observation_Should_Suppress_Event() { //clear existing dependency and let the garbage collector take care of it //(works thanks to weak event listeners). If we didn't change listener remained active dependency = null; GC.Collect(); GC.WaitForPendingFinalizers(); //create settings and disable observations DependencyNodeSettings<ObservableCollection<Student>> settings; settings = new DependencyNodeSettings<ObservableCollection<Student>>(() => course.Students); settings.ChangeHandler = OnDependencyChanged; settings.ObserveSubValueChanges = false; dependency = DependencyBuilder.CreateDependency(settings); //add student to collection course.Students.Add(TestUtil.CreateTestStudent()); Assert.AreEqual(0, eventCounter); //remove student from collection course.Students.Remove(course.Students[7]); Assert.AreEqual(0, eventCounter); }
private static void FlattenDependencyTypesUnified( RestoreTargetGraph targetGraph, Dictionary <string, LibraryIncludeFlags> result) { var nodeQueue = new Queue <DependencyNode>(1); DependencyNode node = null; var unifiedNodes = new Dictionary <string, GraphItem <RemoteResolveResult> >(StringComparer.OrdinalIgnoreCase); // Create a look up table of id -> library // This should contain only packages and projects. If there is a project with the // same name as a package, use the project. // Projects take precedence over packages here to match the resolver behavior. foreach (var item in targetGraph.Flattened .OrderBy(lib => OrderType(lib))) { // Include flags only apply to packages and projects if (IsPackageOrProject(item) && !unifiedNodes.ContainsKey(item.Key.Name)) { unifiedNodes.Add(item.Key.Name, item); } } // Queue all direct references foreach (var graph in targetGraph.Graphs) { foreach (var root in graph.InnerNodes) { // Walk only the projects and packages GraphItem <RemoteResolveResult> unifiedRoot; if (unifiedNodes.TryGetValue(root.Key.Name, out unifiedRoot)) { // Find the initial project -> dependency flags var typeIntersection = GetDependencyType(graph, root); node = new DependencyNode(root.Item, typeIntersection); nodeQueue.Enqueue(node); } } } // Walk the graph using BFS // During the walk find the intersection of the include type flags. // Dependencies can only have less flags the deeper down the graph // we move. Using this we can no-op when a node is encountered that // has already been assigned at least as many flags as the current // node. We can also assume that all dependencies under it are // already correct. If the existing node has less flags then the // walk must continue and all new flags found combined with the // existing ones. while (nodeQueue.Count > 0) { node = nodeQueue.Dequeue(); var rootId = node.Item.Key.Name; // Combine results on the way up LibraryIncludeFlags currentTypes; if (result.TryGetValue(rootId, out currentTypes)) { if ((node.DependencyType & currentTypes) == node.DependencyType) { // Noop, this is done // Circular dependencies end up stopping here also continue; } // Combine the results result[rootId] = (currentTypes | node.DependencyType); } else { // Add the flags we have to the results result.Add(rootId, node.DependencyType); } foreach (var dependency in node.Item.Data.Dependencies) { // Any nodes that are not in unifiedNodes are types that should be ignored // We should also ignore dependencies that are excluded to match the dependency // resolution phase. // Note that we cannot stop here if there are no flags since we still need to mark // the child nodes as having no flags. SuppressParent=all is a special case. GraphItem <RemoteResolveResult> child; if (unifiedNodes.TryGetValue(dependency.Name, out child) && dependency.SuppressParent != LibraryIncludeFlags.All) { // intersect the edges and remove any suppressParent flags LibraryIncludeFlags typeIntersection = (node.DependencyType & dependency.IncludeType & (~dependency.SuppressParent)); var childNode = new DependencyNode(child, typeIntersection); nodeQueue.Enqueue(childNode); } } } }
static DependencyNode AddResourceAsset( string assetPath, Dictionary <string, DependencyNode> assetPathsDict, Action <ProjectIssue> onIssueFound, DependencyNode parent) { // skip C# scripts if (Path.GetExtension(assetPath).Equals(".cs")) { return(null); } if (assetPathsDict.ContainsKey(assetPath)) { var dep = assetPathsDict[assetPath]; if (parent != null) { dep.AddChild(parent); } return(dep); } var location = new Location(assetPath); var dependencyNode = new AssetDependencyNode { location = new Location(assetPath) }; if (parent != null) { dependencyNode.AddChild(parent); } onIssueFound(new ProjectIssue ( k_Descriptor, Path.GetFileNameWithoutExtension(location.Path), IssueCategory.Assets, location ) { dependencies = dependencyNode } ); assetPathsDict.Add(assetPath, dependencyNode); return(dependencyNode); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean permissible(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override bool permissible(GuideUserAction currentAction, ParserConfiguration config) { currentAction.getAction(actionContainers); int trans = transActionContainer.ActionCode; TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; DependencyNode activeStackPeek = planarConfig.ActiveStack.Peek(); DependencyNode inactiveStackPeek = planarConfig.InactiveStack.Peek(); DependencyNode inputPeek = planarConfig.Input.Peek(); IDependencyStructure dg = planarConfig.DependencyGraph; //int rootHandling = planarConfig.getRootHandling(); bool singleHeadConstraint = planarConfig.requiresSingleHead(); bool noCoveredRootsConstraint = planarConfig.requiresNoCoveredRoots(); bool acyclicityConstraint = planarConfig.requiresAcyclicity(); //boolean connectednessConstraintOnReduce = planarConfig.requiresConnectednessCheckOnReduce(); //boolean connectednessConstraintOnShift = planarConfig.requiresConnectednessCheckOnShift(); if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled) { return(false); } //if ((trans == LEFTARC || trans == REDUCE) && stackPeek.isRoot()) { // return false; //} if (trans == LEFTARC) { //avoid making root child of something if (activeStackPeek.Root) { return(false); } //enforce single-head constraint if present if (activeStackPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (activeStackPeek.hasHead() && dg.GetTokenNode(activeStackPeek.Index).Head.Index == inputPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && activeStackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == RIGHTARC) { //enforce single-head constraint if present if (inputPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (inputPeek.hasHead() && dg.GetTokenNode(inputPeek.Index).Head.Index == activeStackPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && activeStackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == REDUCE) { //do not reduce the dummy root if (activeStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!activeStackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } //TODO does this line still make sense? (from Nivre arc-eager) //if ( !stackPeek.hasHead() && rootHandling == PlanarConfig.STRICT ) // return false; //enforce connectedness constraint if present /* * if ( connectednessConstraintOnReduce ) * { * boolean path1 = ( stackPeek.findComponent().getIndex() == inputPeek.findComponent().getIndex() ); * boolean path2; * if ( planarConfig.getStack().size() < 2 ) path2=false; * else * { * DependencyNode stackPrev = planarConfig.getStack().get(planarConfig.getStack().size()-2); * path2 = stackPrev.findComponent().getIndex() == stackPeek.findComponent().getIndex(); * } * return path1 || path2; * } */ } if (trans == SHIFT) { /* * if ( connectednessConstraintOnShift && planarConfig.getInput().size() == 1 ) //last word * { * boolean path = ( planarConfig.getDependencyGraph().getTokenNode(1).findComponent().getIndex() == inputPeek.findComponent().getIndex() ); //require connection to 1st * return path; * } */ } if (trans == REDUCEBOTH) { //do not reduce the dummy root if (activeStackPeek.Root || inactiveStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if ((!activeStackPeek.hasHead() || inactiveStackPeek.hasHead()) && noCoveredRootsConstraint) { return(false); } //TODO remove this: //not using this transition at the moment, so return(false); } if (trans == SWITCH) { if (planarConfig.reduceAfterSwitch()) { if (inactiveStackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!inactiveStackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } } else { if (planarConfig.LastAction == SWITCH) { return(false); } } } return(true); }
void RequireLinkBase_PreRender(object sender, EventArgs e) { DependencyGraph<String, RequireLinkBase> graph = GetDependencyGraph(); DependencyNode<String, RequireLinkBase> node = new DependencyNode<String, RequireLinkBase>(Key, this, ParseDependencies(After ?? "")); if (!graph.Graph.Any(n => n.Key == Key)) graph.Graph.Add(node); // todo: merge dependencies if it's a dupe }
public ResolvableService(string serviceTypeName, DependencyNode dependencies) { ServiceTypeName = serviceTypeName; Dependencies = dependencies; }
public MyApplication() { //create a dependency on the city of the student's school dependency = DependencyNode.Create(() => MyStudent.School.Address.City); dependency.DependencyChanged += OnStudentCityChanged; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean permissible(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override bool permissible(GuideUserAction currentAction, ParserConfiguration config) { currentAction.getAction(actionContainers); int trans = transActionContainer.ActionCode; PlanarConfig planarConfig = (PlanarConfig)config; DependencyNode stackPeek = planarConfig.Stack.Peek(); DependencyNode inputPeek = planarConfig.Input.Peek(); IDependencyStructure dg = planarConfig.DependencyGraph; //int rootHandling = planarConfig.getRootHandling(); bool singleHeadConstraint = planarConfig.requiresSingleHead(); bool noCoveredRootsConstraint = planarConfig.requiresNoCoveredRoots(); bool acyclicityConstraint = planarConfig.requiresAcyclicity(); bool connectednessConstraintOnReduce = planarConfig.requiresConnectednessCheckOnReduce(); bool connectednessConstraintOnShift = planarConfig.requiresConnectednessCheckOnShift(); if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled) { return(false); } //if ((trans == LEFTARC || trans == REDUCE) && stackPeek.isRoot()) { // return false; //} if (trans == LEFTARC) { //avoid making root child of something if (stackPeek.Root) { return(false); } //enforce single-head constraint if present if (stackPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (stackPeek.hasHead() && dg.GetTokenNode(stackPeek.Index).Head.Index == inputPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && stackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == RIGHTARC) { //enforce single-head constraint if present if (inputPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (inputPeek.hasHead() && dg.GetTokenNode(inputPeek.Index).Head.Index == stackPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && stackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == REDUCE) { //do not reduce the dummy root if (stackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!stackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } //TODO does this line still make sense? (from Nivre arc-eager) //if ( !stackPeek.hasHead() && rootHandling == PlanarConfig.STRICT ) // return false; //enforce connectedness constraint if present if (connectednessConstraintOnReduce) { bool path1 = (stackPeek.findComponent().Index == inputPeek.findComponent().Index); bool path2; if (planarConfig.Stack.Count < 2) { path2 = false; } else { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: DependencyNode stackPrev = planarConfig.Stack.get(planarConfig.Stack.Count - 2); path2 = stackPrev.findComponent().Index == stackPeek.findComponent().Index; } return(path1 || path2); } } if (trans == SHIFT) { if (connectednessConstraintOnShift && planarConfig.Input.Count == 1) //last word { bool path = (planarConfig.DependencyGraph.GetTokenNode(1).findComponent().Index == inputPeek.findComponent().Index); //require connection to 1st return(path); } } return(true); }
private List <DependencyNode> findAllDependentsVectorSortedByDistanceToPProjNode2(IDependencyStructure dg, DependencyNode governor, DependencyNode avoid, bool percentOnly) { int i, j; List <DependencyNode> dependents = new List <DependencyNode>(); DependencyNode leftChild, rightChild; i = governor.LeftDependentCount - 1; j = 0; leftChild = governor.getLeftDependent(i--); rightChild = governor.getRightDependent(j++); while (leftChild != null && rightChild != null) { if (leftChild == avoid) { leftChild = governor.getLeftDependent(i--); } else if (rightChild == avoid) { rightChild = governor.getRightDependent(j++); } else if (Math.Abs(leftChild.Index - avoid.Index) < Math.Abs(rightChild.Index - avoid.Index)) { if (!percentOnly || (percentOnly && nodePath[leftChild.Index])) { dependents.Add(leftChild); } leftChild = governor.getLeftDependent(i--); } else { if (!percentOnly || (percentOnly && nodePath[rightChild.Index])) { dependents.Add(rightChild); } rightChild = governor.getRightDependent(j++); } } while (leftChild != null) { if (leftChild != avoid && (!percentOnly || (percentOnly && nodePath[leftChild.Index]))) { dependents.Add(leftChild); } leftChild = governor.getLeftDependent(i--); } while (rightChild != null) { if (rightChild != avoid && (!percentOnly || (percentOnly && nodePath[rightChild.Index]))) { dependents.Add(rightChild); } rightChild = governor.getRightDependent(j++); } return(dependents); }
public void Monitoring_A_Collection_Item_Should_Work() { var dep = DependencyNode.Create(() => course.Students.FirstOrDefault(s => s.Age > 20)); }
public bool Equals(DependencyNode <T, TKey> other) { return(other != null && Key.Equals(other.Key)); }
private static bool Produces(DependencyNode n, ValueSpecification specToTest) { var targetMatches = n.Target.UniqueId == specToTest.TargetSpecification.Uid && n.Target.Type == specToTest.TargetSpecification.Type; return(targetMatches && n.OutputValues.Any(s => s.Equals(specToTest))); }
public DependencyNode(string assetBundleName, DependencyNode parent) { parentNode = parent; this.assetBundleName = assetBundleName; }
public ServiceConstructor(string serviceTypeName, string constructorName, DependencyNode dependencies) { ServiceTypeName = serviceTypeName; ConstructorName = constructorName; Dependencies = dependencies; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: protected org.maltparser.core.syntaxgraph.edge.Edge moveDependencyEdge(org.maltparser.core.syntaxgraph.node.DependencyNode newHead, org.maltparser.core.syntaxgraph.node.DependencyNode dependent) throws org.maltparser.core.exception.MaltChainedException protected internal virtual Edge.Edge moveDependencyEdge(DependencyNode newHead, DependencyNode dependent) { if (dependent == null || !dependent.hasHead()) { return(null); } Edge.Edge headEdge = dependent.HeadEdge; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LabelSet labels = checkOutNewLabelSet(); LabelSet labels = CheckOutNewLabelSet(); foreach (SymbolTable table in headEdge.LabelTypes) { labels.put(table, headEdge.getLabelCode(table)); } headEdge.clear(); headEdge.BelongsToGraph = this; headEdge.setEdge((Node.Node)newHead, (Node.Node)dependent, Edge_Fields.DEPENDENCY_EDGE); headEdge.addLabel(labels); labels.clear(); CheckInLabelSet(labels); return(headEdge); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void updatePhraseStructureGraph(org.maltparser.core.syntaxgraph.MappablePhraseStructureGraph graph, org.maltparser.core.syntaxgraph.edge.Edge depEdge, boolean attachHeadSpineToRoot) throws org.maltparser.core.exception.MaltChainedException public virtual void updatePhraseStructureGraph(MappablePhraseStructureGraph graph, Edge.Edge depEdge, bool attachHeadSpineToRoot) { PhraseStructureNode dependentSpine = (PhraseStructureNode)depEdge.Target; if (((PhraseStructureNode)depEdge.Target).Parent == null) { // Restore dependent spine string phraseSpineLabel = null; string edgeSpineLabel = null; int empty_label = 0; if (depEdge.hasLabel(graph.SymbolTables.getSymbolTable(PHRASE))) { phraseSpineLabel = depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(PHRASE)); } if (depEdge.hasLabel(graph.SymbolTables.getSymbolTable(HEADREL))) { edgeSpineLabel = depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(HEADREL)); } if (!ReferenceEquals(phraseSpineLabel, null) && phraseSpineLabel.Length > 0 && phraseSpineLabel[0] != EMPTY_SPINE) { int ps = 0, es = 0, i = 0, j = 0, n = phraseSpineLabel.Length - 1, m = edgeSpineLabel.Length - 1; PhraseStructureNode child = (PhraseStructureNode)depEdge.Target; while (true) { while (i <= n && phraseSpineLabel[i] != SPINE_ELEMENT_SEPARATOR) { if (phraseSpineLabel[i] == QUESTIONMARK) { empty_label++; } else { empty_label = 0; } i++; } if (depEdge.Source.Root && i >= n) { dependentSpine = graph.PhraseStructureRoot; } else { dependentSpine = graph.addNonTerminalNode(++nonTerminalCounter); } if (empty_label != 2 && ps != i) { dependentSpine.addLabel(graph.SymbolTables.addSymbolTable(CAT), phraseSpineLabel.Substring(ps, i - ps)); } empty_label = 0; if (!ReferenceEquals(edgeSpineLabel, null)) { while (j <= m && edgeSpineLabel[j] != SPINE_ELEMENT_SEPARATOR) { if (edgeSpineLabel[j] == QUESTIONMARK) { empty_label++; } else { empty_label = 0; } j++; } } lockUpdate = true; Edge.Edge e = graph.addPhraseStructureEdge(dependentSpine, child); if (empty_label != 2 && es != j && !ReferenceEquals(edgeSpineLabel, null) && e != null) { e.addLabel(graph.SymbolTables.addSymbolTable(EDGELABEL), edgeSpineLabel.Substring(es, j - es)); } else if (es == j) { e.addLabel(graph.SymbolTables.addSymbolTable(EDGELABEL), EMPTY_LABEL); } lockUpdate = false; child = dependentSpine; if (i >= n) { break; } empty_label = 0; ps = i = i + 1; es = j = j + 1; } } // Recursively attach the dependent spines to target node. DependencyNode target = (DependencyNode)depEdge.Target; for (int i = 0; i < target.LeftDependentCount; i++) { updatePhraseStructureGraph(graph, target.getLeftDependent(i).HeadEdge, attachHeadSpineToRoot); } for (int i = target.RightDependentCount - 1; i >= 0; i--) { updatePhraseStructureGraph(graph, target.getRightDependent(i).HeadEdge, attachHeadSpineToRoot); } } else { // If dependent spine already exist, then set dependentSpine to the highest nonterminal // of the dependent spine. while (dependentSpine.Parent != null && !dependentSpine.Parent.Root) { dependentSpine = dependentSpine.Parent; } } PhraseStructureNode headSpine = null; if (((PhraseStructureNode)depEdge.Source).Parent != null) { // If head spine exist, then attach dependent spine to the head spine at the attachment level a. int a = 0; headSpine = ((PhraseStructureNode)depEdge.Source).Parent; if (depEdge.hasLabel(graph.SymbolTables.getSymbolTable(ATTACH))) { try { a = int.Parse((depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(ATTACH)))); } catch (FormatException e) { throw new MaltChainedException(e.Message); } } for (int i = 0; i < a && headSpine != null; i++) { headSpine = headSpine.Parent; } if ((headSpine == null || headSpine == dependentSpine) && attachHeadSpineToRoot) { headSpine = graph.PhraseStructureRoot; } if (headSpine != null) { lockUpdate = true; Edge.Edge e = graph.addPhraseStructureEdge(headSpine, dependentSpine); if (depEdge.hasLabel(graph.SymbolTables.getSymbolTable(DEPREL)) && !depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(DEPREL)).Equals(EMPTY_LABEL) & e != null) { e.addLabel(graph.SymbolTables.addSymbolTable(EDGELABEL), depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(DEPREL))); } lockUpdate = false; } } else if (depEdge.Source.Root && !depEdge.Labeled) { headSpine = graph.PhraseStructureRoot; lockUpdate = true; Edge.Edge e = graph.addPhraseStructureEdge(headSpine, dependentSpine); if (depEdge.hasLabel(graph.SymbolTables.getSymbolTable(DEPREL)) && !depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(DEPREL)).Equals(EMPTY_LABEL) & e != null) { e.addLabel(graph.SymbolTables.addSymbolTable(EDGELABEL), depEdge.getLabelSymbol(graph.SymbolTables.getSymbolTable(DEPREL))); } else { e.addLabel(graph.SymbolTables.addSymbolTable(EDGELABEL), graph.GetDefaultRootEdgeLabelSymbol(graph.SymbolTables.getSymbolTable(DEPREL))); } lockUpdate = false; // Recursively attach the dependent spines to target node. DependencyNode target = (DependencyNode)depEdge.Target; for (int i = 0; i < target.LeftDependentCount; i++) { updatePhraseStructureGraph(graph, target.getLeftDependent(i).HeadEdge, attachHeadSpineToRoot); } for (int i = target.RightDependentCount - 1; i >= 0; i--) { updatePhraseStructureGraph(graph, target.getRightDependent(i).HeadEdge, attachHeadSpineToRoot); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private boolean projectiveInterval(org.maltparser.core.syntaxgraph.DependencyStructure parse, org.maltparser.core.syntaxgraph.node.DependencyNode left, org.maltparser.core.syntaxgraph.node.DependencyNode right) throws org.maltparser.core.exception.MaltChainedException private bool projectiveInterval(IDependencyStructure parse, DependencyNode left, DependencyNode right) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int l = swapArray.get(left.getIndex()); int l = swapArray[left.Index]; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int r = swapArray.get(right.getIndex()); int r = swapArray[right.Index]; DependencyNode node = null; if (l > r) { return(false); } else { for (int i = l + 1; i < r; i++) { for (int j = 0; j < swapArray.Count; j++) { if (swapArray[j] == i) { node = parse.GetDependencyNode(j); break; } } while (node.hasHead()) { node = node.Head; } if (!(node == left || node == right)) { return(false); } } return(true); } }
public void Init() { //create a dependency that contains a unary expression (NOT) dependency = DependencyNode.Create(() => !SomeBool); dependency.DependencyChanged += delegate { eventCounter++; }; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void update() throws org.maltparser.core.exception.MaltChainedException public void update() { // Retrieve the address value //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.feature.value.AddressValue arg1 = addressFunction1.getAddressValue(); AddressValue arg1 = addressFunction1.AddressValue; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.feature.value.AddressValue arg2 = addressFunction2.getAddressValue(); AddressValue arg2 = addressFunction2.AddressValue; try { if (arg1.Address == null || arg2.Address == null) { featureValue.IndexCode = table.getNullValueCode(NullValueId.NO_NODE); featureValue.Symbol = table.getNullValueSymbol(NullValueId.NO_NODE); featureValue.NullValue = true; } else { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node1 = (org.maltparser.core.syntaxgraph.node.DependencyNode)arg1.getAddress(); DependencyNode node1 = (DependencyNode)arg1.Address; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node2 = (org.maltparser.core.syntaxgraph.node.DependencyNode)arg2.getAddress(); DependencyNode node2 = (DependencyNode)arg2.Address; int head1 = -1; int head2 = -1; if (node1.hasHead()) { head1 = node1.Head.Index; //lines below don't seem to work //head1 = Integer.parseInt(node1.getHeadEdgeLabelSymbol(column.getSymbolTable())); //if ( node1.hasHeadEdgeLabel(column.getSymbolTable()) ) // head1 = Integer.parseInt(node1.getHeadEdgeLabelSymbol(column.getSymbolTable())); } if (node2.hasHead()) { head2 = node2.Head.Index; //lines below don't seem to work //head2 = Integer.parseInt(node2.getHeadEdgeLabelSymbol(column.getSymbolTable())); //if ( node2.hasHeadEdgeLabel(column.getSymbolTable()) ) // head2 = Integer.parseInt(node2.getHeadEdgeLabelSymbol(column.getSymbolTable())); } if (!node1.Root && head1 == node2.Index) { featureValue.IndexCode = table.getSymbolStringToCode("LEFT"); featureValue.Symbol = "LEFT"; featureValue.NullValue = false; } else if (!node2.Root && head2 == node1.Index) { featureValue.IndexCode = table.getSymbolStringToCode("RIGHT"); featureValue.Symbol = "RIGHT"; featureValue.NullValue = false; } else { featureValue.IndexCode = table.getNullValueCode(NullValueId.NO_NODE); featureValue.Symbol = table.getNullValueSymbol(NullValueId.NO_NODE); featureValue.NullValue = true; } } } catch (FormatException e) { throw new FeatureException("The index of the feature must be an integer value. ", e); } featureValue.Value = 1; }
private DependencyNode breadthFirstSearchSortedByDistanceForPath(IDependencyStructure dg, DependencyNode start, DependencyNode avoid) { DependencyNode dependent; List <DependencyNode> nodes = new List <DependencyNode>(), newNodes; nodes.AddRange(findAllDependentsVectorSortedByDistanceToPProjNode(dg, start, avoid, true)); while (nodes.Count > 0) { dependent = nodes.RemoveAt(0); if (((newNodes = findAllDependentsVectorSortedByDistanceToPProjNode(dg, dependent, avoid, true)).Count) == 0) { return(dependent); } nodes.AddRange(newNodes); } return(null); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void updateDependencyEdges(org.maltparser.core.syntaxgraph.MappablePhraseStructureGraph graph, org.maltparser.core.syntaxgraph.node.PhraseStructureNode top) throws org.maltparser.core.exception.MaltChainedException private void updateDependencyEdges(MappablePhraseStructureGraph graph, PhraseStructureNode top) { if (top == null) { return; } DependencyNode head = null; DependencyNode dependent = null; if (top is NonTerminalNode) { foreach (PhraseStructureNode node in ((NonTerminalNode)top).Children) { if (node is NonTerminalNode) { updateDependencyEdges(graph, node); } else { head = ((NonTerminalNode)top).getLexicalHead(headRules); dependent = (DependencyNode)node; if (head != null && dependent != null && head != dependent) { lockUpdate = true; if (!dependent.hasHead()) { graph.addDependencyEdge(head, dependent); } else if (head != dependent.Head) { graph.moveDependencyEdge(head, dependent); } lockUpdate = false; } } } } head = null; if (top.Parent != null) { head = ((NonTerminalNode)top.Parent).getLexicalHead(headRules); } else if (top.Root) { head = (DependencyNode)top; } if (top is NonTerminalNode) { dependent = ((NonTerminalNode)top).getLexicalHead(headRules); } else if (!top.Root) { dependent = (DependencyNode)top; } if (head != null && dependent != null && head != dependent) { lockUpdate = true; if (!dependent.hasHead()) { graph.addDependencyEdge(head, dependent); } else if (head != dependent.Head) { graph.moveDependencyEdge(head, dependent); } lockUpdate = false; } }
public void Init() { eventCounter = 0; lastEventArgs = null; course = new Course(); for (int i = 0; i < 10; i++) { var student = TestUtil.CreateTestStudent(); student.Name = "Student " + i; course.Students.Add(student); } dependency = DependencyNode.Create(() => course.Students); dependency.DependencyChanged += OnDependencyChanged; }
public void GetDependencyDepth() { // TODO: Fill this method to find how many dependencies needs to be validated before this one will // Like that it will be easy to paint into the graph in columns Queue <DependencyNode> dependenciesToVisit = new Queue <DependencyNode>(dependencies); List <DependencyNode> alreadyVisitedDependencies = new List <DependencyNode>(dependencies); if (dependencies == null || dependencies.Count == 0) { depth = someIsDependentOfMe ? 1 : 0; nodeRectangle.x = nodeRectangle.width * depth; return; } depth = 2; nodeRectangle.x = (nodeRectangle.width + 100) * depth; List <DependencyNode> newDependenciesToVisit = new List <DependencyNode>(); while (dependenciesToVisit.Count > 0) { DependencyNode node = dependenciesToVisit.Dequeue(); if (node.IsDepdendent) { foreach (DependencyNode n in node.dependencies) { if (!alreadyVisitedDependencies.Contains(n) && !newDependenciesToVisit.Contains(n)) { newDependenciesToVisit.Add(n); } } } else { return; } alreadyVisitedDependencies.Add(node); if (dependenciesToVisit.Count == 0 && newDependenciesToVisit.Count > 0) { depth++; nodeRectangle.x = (nodeRectangle.width + 100) * depth; bool cont = false; foreach (DependencyNode depNode in newDependenciesToVisit) { if (!alreadyVisitedDependencies.Contains(depNode)) { cont = true; } } if (cont) { dependenciesToVisit = new Queue <DependencyNode>(newDependenciesToVisit); } else { return; } } } }
public static bool InSameDatabase(this SqlSmoObject sqlSmoObject, DependencyNode x) { return 0 == string.Compare( x.Urn.GetNameForType(Const.Database), sqlSmoObject.Urn.GetNameForType(Const.Database), StringComparison.InvariantCultureIgnoreCase); }
static IEnumerable <DependencyNode <ContributorNotification> > GetCompatibleTypes(DependencyTree <ContributorNotification> tree, DependencyNode <ContributorNotification> notificationNode, IEnumerable <Type> beforeTypes) { return(from childType in beforeTypes from compatibleNode in tree.Nodes where compatibleNode != notificationNode && childType.IsAssignableFrom(compatibleNode.Value.Contributor.GetType()) select compatibleNode); }
public DependencyNode(string ownerPath, DependencyNode parent) : this(AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(ownerPath)) { Parent = parent; Space = Parent.Space + 20; }
/// <summary> /// Cause the feature function to update the feature value. /// </summary> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void update() throws org.maltparser.core.exception.MaltChainedException public void update() { // Retrieve the address value //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.feature.value.AddressValue arg1 = addressFunction1.getAddressValue(); AddressValue arg1 = addressFunction1.AddressValue; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.feature.value.AddressValue arg2 = addressFunction2.getAddressValue(); AddressValue arg2 = addressFunction2.AddressValue; // featureValue.setKnown(true); // if arg1 or arg2 is null, then set a NO_NODE null value as feature value if (arg1.Address == null || arg2.Address == null) { featureValue.IndexCode = table.getNullValueCode(NullValueId.NO_NODE); featureValue.Symbol = table.getNullValueSymbol(NullValueId.NO_NODE); featureValue.Value = 1; featureValue.NullValue = true; } else { // Unfortunately this method takes a lot of time arg1.getAddressClass().asSubclass(org.maltparser.core.syntaxgraph.node.DependencyNode.class); // Cast the address arguments to dependency nodes //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node1 = (org.maltparser.core.syntaxgraph.node.DependencyNode)arg1.getAddress(); DependencyNode node1 = (DependencyNode)arg1.Address; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node2 = (org.maltparser.core.syntaxgraph.node.DependencyNode)arg2.getAddress(); DependencyNode node2 = (DependencyNode)arg2.Address; if (!node1.Root && !node2.Root) { // Calculates the distance //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int index1 = node1.getIndex(); int index1 = node1.Index; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int index2 = node2.getIndex(); int index2 = node2.Index; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int distance = Math.abs(index1-index2); int distance = Math.Abs(index1 - index2); int lower = -1; bool f = false; foreach (int?upper in normalization.Keys) { if (distance >= lower && distance < upper.Value) { featureValue.IndexCode = table.getSymbolStringToCode(normalization[lower]); featureValue.Symbol = normalization[lower]; featureValue.Value = 1; f = true; break; } lower = upper.Value; } if (f == false) { featureValue.IndexCode = table.getSymbolStringToCode(normalization[lower]); featureValue.Symbol = normalization[lower]; featureValue.Value = 1; } // Tells the feature value that the feature is known and is not a null value featureValue.NullValue = false; } else { // if node1 or node2 is a root node, set a ROOT_NODE null value as feature value featureValue.IndexCode = table.getNullValueCode(NullValueId.ROOT_NODE); featureValue.Symbol = table.getNullValueSymbol(NullValueId.ROOT_NODE); featureValue.Value = 1; featureValue.NullValue = true; } } }
void OnGUINode(DependencyNode node, bool forceDisplay = false) { if (!node.IsChecked) { node.Check(); } if (!forceDisplay && !node.RequireDisplay) { return; } bool beginDisabledGroup = false; if (forceDisplay && !node.RequireDisplay) { EditorGUI.BeginDisabledGroup(true); beginDisabledGroup = true; } int arrowWidth = 20; int iconWidth = 16; using (new EditorGUILayout.HorizontalScope()) { GUILayout.Space(node.Space); if (node.HasDependencies) { if (GUILayout.Button((node.IsOpened ? " ▼" : " ▶︎"), GUI.skin.label, GUILayout.Width(arrowWidth))) { node.IsOpened = !node.IsOpened; } } else { if (GUILayout.Button(" ", GUI.skin.label, GUILayout.Width(arrowWidth))) { } } var rect = GUILayoutUtility.GetLastRect(); rect.x += iconWidth; GUI.DrawTexture(rect, node.Icon, ScaleMode.ScaleToFit); GUILayout.Space(iconWidth - 3); if (GUILayout.Button(node.Owner.name, GUI.skin.label)) { EditorGUIUtility.PingObject(node.Owner); } } if (node.IsOpened) { if (node.HasDependencies) { using (new EditorGUI.IndentLevelScope()) { foreach (var dependencyNode in node.Dependencies) { OnGUINode(dependencyNode); } } } } if (beginDisabledGroup) { EditorGUI.EndDisabledGroup(); } }
/// <summary> /// Add to the seen list for tracking. /// </summary> /// <returns>True if the node should be walked</returns> private static bool AddToSeen(Dictionary <string, NodeWarningProperties> seen, DependencyNode node) { var id = node.Id; var nodeProps = node.NodeWarningProperties; if (!seen.TryGetValue(id, out var visitedProps)) { // New id seen.Add(id, nodeProps); return(true); } if (!nodeProps.IsSubSetOf(visitedProps)) { // Find the intersection of properties between these nodes, // these are the only properties that we need to look for in // future passes. seen[id] = nodeProps.GetIntersect(visitedProps); return(true); } // This has already been walked return(false); }
/// <summary> /// Inits the <see cref="Dependency"/> property. The default implementation /// registers a dependency on the school's city. /// </summary> protected virtual void CreateDependency() { Dependency = DependencyNode.Create(() => Student.School.Address.City); }
private void IterateNodes(DependencyNode node, AttributeContext<DependsOnAttribute> context, IModule item, ref bool added) { if (node.Nodes.ContainsKey(context.AttributeInstance.DependencyType)) { node.Nodes[context.AttributeInstance.DependencyType].Nodes.Add(item.GetType(), new DependencyNode(item)); added = true; } else if (node.Nodes.Count == 0) { added = false; } else { foreach (var child in node.Nodes.Values) { IterateNodes(child, context, item, ref added); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.parser.history.action.GuideUserAction predict(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration config) { TwoPlanarConfig planarConfig = (TwoPlanarConfig)config; IDependencyStructure dg = planarConfig.DependencyGraph; DependencyNode activeStackPeek = planarConfig.ActiveStack.Peek(); DependencyNode inactiveStackPeek = planarConfig.InactiveStack.Peek(); int activeStackPeekIndex = activeStackPeek.Index; int inactiveStackPeekIndex = inactiveStackPeek.Index; int inputPeekIndex = planarConfig.Input.Peek().Index; //System.out.println("Initting crossings"); if (crossingsGraph == null) { initCrossingsGraph(gold); } //System.out.println("Crossings initted"); if (!activeStackPeek.Root && gold.GetTokenNode(activeStackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, activeStackPeekIndex)) { if (planarConfig.StackActivityState == TwoPlanarConfig.FIRST_STACK) { propagatePlaneConstraint(gold.GetTokenNode(activeStackPeekIndex).HeadEdge, FIRST_PLANE); } else { propagatePlaneConstraint(gold.GetTokenNode(activeStackPeekIndex).HeadEdge, SECOND_PLANE); } //System.out.println("From " + inputPeekIndex + " to " + activeStackPeekIndex); return(updateActionContainers(TwoPlanar.LEFTARC, gold.GetTokenNode(activeStackPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == activeStackPeekIndex && !checkIfArcExists(dg, activeStackPeekIndex, inputPeekIndex)) { if (planarConfig.StackActivityState == TwoPlanarConfig.FIRST_STACK) { propagatePlaneConstraint(gold.GetTokenNode(inputPeekIndex).HeadEdge, FIRST_PLANE); } else { propagatePlaneConstraint(gold.GetTokenNode(inputPeekIndex).HeadEdge, SECOND_PLANE); } //System.out.println("From " + activeStackPeekIndex + " to " + inputPeekIndex); return(updateActionContainers(TwoPlanar.RIGHTARC, gold.GetTokenNode(inputPeekIndex).HeadEdge.LabelSet)); } else if (!inactiveStackPeek.Root && gold.GetTokenNode(inactiveStackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, inactiveStackPeekIndex)) { //need to create link, but on the other plane!! //TODO is this if branch really necessary? i.e. will this happen? (later branches already switch) //System.out.println("Switch one"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == inactiveStackPeekIndex && !checkIfArcExists(dg, inactiveStackPeekIndex, inputPeekIndex)) { //need to create link, but on the other plane!! //TODO is this if branch really necessary? i.e. will this happen? (later branches already switch) //System.out.println("Switch two"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } else if (getFirstPendingLinkOnActivePlane(planarConfig, gold) != null) { //System.out.println("Reduce one"); return(updateActionContainers(TwoPlanar.REDUCE, null)); } else if (getFirstPendingLinkOnInactivePlane(planarConfig, gold) != null) { //System.out.println("Switch for reducing"); return(updateActionContainers(TwoPlanar.SWITCH, null)); } //TODO: double reduce somehow? (check if reduced node is not covered by links of the other plane, or something like that). else { //System.out.println("Shift"); return(updateActionContainers(TwoPlanar.SHIFT, null)); } }
public void Monitoring_A_Collection_Item_Should_Work() { //this is currently not supported var dep = DependencyNode.Create(() => course.Students.FirstOrDefault(s => s.Age > 20)); }
private bool CheckDependenciesExist(DependencyNode node) { HashSet<string> effectiveExistingObjectNames = new HashSet<string>(existingObjectNames, existingObjectNames.Comparer); effectiveExistingObjectNames.ExceptWith(dependencies.Keys); return effectiveExistingObjectNames.IsSupersetOf(node.Edges); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private boolean necessarySwap(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.core.syntaxgraph.DependencyStructure parse, org.maltparser.core.syntaxgraph.node.DependencyNode node, java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> input) throws org.maltparser.core.exception.MaltChainedException private bool necessarySwap(IDependencyStructure gold, IDependencyStructure parse, DependencyNode node, Stack <DependencyNode> input) { DependencyNode left = node; int index = input.Count - 1; if (index < 0) { return(true); } DependencyNode right = input.Peek(); int rc = -1; while (projectiveInterval(parse, left, right)) { if (rc == right.Index) { return(false); } if (gold.GetDependencyNode(node.Index).Head.Index == right.Index) { return(!leftComplete(gold, node)); } if (gold.GetDependencyNode(right.Index).Head.Index == node.Index) { if (gold.GetDependencyNode(right.Index).hasRightDependent()) { rc = gold.GetDependencyNode(right.Index).RightmostProperDescendantIndex; } else { return(false); } } if (index > 0) { left = right; //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: right = input.get(--index); } else { break; } } return(true); }
private IEnumerable<DependencyNode> GetAllDependencies(DependencyNode node) { HashSet<DependencyNode> result = new HashSet<DependencyNode>(); Queue<DependencyNode> queue = new Queue<DependencyNode>(); queue.Enqueue(node); do { DependencyNode dependencyNode = queue.Dequeue(); if (result.Add(dependencyNode)) { foreach (string edge in dependencyNode.Edges) { List<DependencyNode> dependencyNodes; if (dependencies.TryGetValue(edge, out dependencyNodes)) { foreach (DependencyNode innerDependency in dependencyNodes) { queue.Enqueue(innerDependency); } } } } } while (queue.Count > 0); return result; }
private String GetCodeForNodeData(List <NodeDataSection> nodeDataSections, Relocation[] relocs, byte[] byteData, DependencyNode node, int offset, NodeFactory factory) { CppGenerationBuffer nodeDataDecl = new CppGenerationBuffer(); int relocCounter = 0; int divisionStartIndex = offset; nodeDataDecl.Indent(); nodeDataDecl.Indent(); nodeDataDecl.AppendLine(); for (int i = 0; i < nodeDataSections.Count; i++) { if (nodeDataSections[i].SectionType == NodeDataSectionType.Relocation) { Relocation reloc = relocs[relocCounter]; nodeDataDecl.Append(GetCodeForReloc(reloc, node, factory)); nodeDataDecl.Append(","); relocCounter++; } else { AppendFormattedByteArray(nodeDataDecl, byteData, divisionStartIndex, divisionStartIndex + nodeDataSections[i].SectionSize); nodeDataDecl.Append(","); } divisionStartIndex += nodeDataSections[i].SectionSize; nodeDataDecl.AppendLine(); } return(nodeDataDecl.ToString()); }
private void RemoveDependency(DependencyNode node) { List<DependencyNode> dependencyNodes = dependencies[node.ObjectName]; dependencyNodes.Remove(node); if (dependencyNodes.Count == 0) { dependencies.Remove(node.ObjectName); existingObjectNames.Add(node.ObjectName); } }