/// <summary> /// 直接运行于环境默认的上 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="self"></param> /// <returns></returns> public static T Run <T>(this T self) where T : IActionNode { NodeIterator it = NodeIterator.Allocate <NodeIterator>(self.env); it.Config(self); return(self); }
public void ShouldReturnTablesInCorrectOrder() { // Scenario: Make 2 customers, for each customer make two accounts and do one deposit and one withdraw for each account string[] requestedOrder = { "Customer", "Account", "Deposit", "Withdraw", "Account", "Deposit", "Withdraw", "Customer", "Account", "Deposit", "Withdraw", "Account", "Deposit", "Withdraw", }; // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); var actual = new List <TableEntity>(it.GetTablesRecursive().Select(x => x.Table)); for (int i = 0; i < requestedOrder.Length; i++) { Console.WriteLine(actual[i].TableName); Assert.That(requestedOrder[i], Is.EqualTo(actual[i].TableName)); } }
/// <summary>Gets the nearest focusable element below this.</summary> /// <returns>The nearest focusable element below. Null if there is none.</returns> public HtmlElement GetFocusableBelow() { // Has the element defined something specific? HtmlElement target = GetFocusableOverride("down"); if (target != null) { // Yep, it did! return(target); } // Distance of the nearest element (set when nearest is first set): float nearestDistance = 0f; // The current nearest element: HtmlElement nearest = null; // Grab my computed style: ComputedStyle computed = Style.Computed; // Get hold of the iterator (so we can safely skip child elements): NodeIterator allElements = document.allNodes; // Grab my x position: float myX = computed.GetMidpointX(); // Grab the midpoint of this element on Y: float myY = computed.GetMidpointY(); // For each element in the dom that is focusable and below this.. foreach (Node node in allElements) { HtmlElement element = node as HtmlElement; if (element == null) { continue; } if (element != this && element.IsBelow(myY) && element.focusable) { // We have an element below. // Check if it is closer than the current result. // If it is, it's the current result. // Is it nearer? float distance = element.DistanceFromFast(myX, myY); // Is it the first we've found, or is it nearer? if (nearest == null || distance < nearestDistance) { nearest = element; nearestDistance = distance; } // Make sure we don't now iterate its kids: allElements.SkipChildren = true; } } return(nearest); }
public void ForEachNode(NodeIterator it) { for (int i = 0; i < NodeCount; i++) { it(i); } }
public void ShouldGetZeroTotalExpectedInsertedRowWhenThereIsNoTable() { ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "No tables"); NodeIterator it = new NodeIterator(customer); long actualExpectedCount = it.GetExpectedInsertCount(); Assert.That(actualExpectedCount, Is.EqualTo(0)); }
public override bool Equals(object other) { NodeIterator iter = other as NodeIterator; if (iter == null) { return(false); } return(object.ReferenceEquals(current, iter.current)); }
public override object Execute(IContextProvider provider, object[] dataPool) { XPath2NodeIterator iter = XPath2NodeIterator.Create(this[0].Execute(provider, dataPool)); for (int k = 1; k < Count; k++) { iter = new NodeIterator(CreateEnumerator(dataPool, this[k], iter)); } return(iter); }
public override int Distance(Iterator <KeyValuePair <TKey, TValue> > iter) { NodeIterator nodeIter = iter as NodeIterator; if (nodeIter == null || !object.ReferenceEquals(nodeIter.Collection, this.Collection)) { throw new ArgumentException("Cannot determine distance of iterators belonging to different collections."); } var end = tree.end; int keyDiff; if (this == end || iter == end) { keyDiff = (this == end && this != iter) ? 1 : 0; } else { keyDiff = tree.keyComparer.Compare(current.Key, nodeIter.current.Key); } if (keyDiff <= 0) { int diff = 0; var rwd = this.Clone(); for (; rwd != iter && rwd != end; rwd.Next()) { --diff; } if (rwd == iter) { return(diff); } } if (keyDiff >= 0) { int diff = 0; var fwd = iter.Clone(); for (; fwd != this && fwd != end; fwd.Next()) { ++diff; } if (fwd == this) { return(diff); } } throw new Exception("Inconsistent state. Concurrency?"); }
public IEnumerable <RelatedNode> GetStartNodesArriveToEnd(Int32 lengthPath) { var nodeIterator = new NodeIterator(this); while (nodeIterator.MoveNext()) { if (nodeIterator.Current.CanMoveToEnd(lengthPath)) { yield return(nodeIterator.Current); } } }
public void ShouldNotAllowNullInTheParameterForNodeIterator() { bool thrown = false; ExecutionNode node = null; try { NodeIterator it = new NodeIterator(node); } catch (ArgumentNullException) { thrown = true; } Assert.That(thrown, Is.True); }
public void ShouldBeAbleToRemoveSeveralTablesFromExecutionNode() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(_CustomerTable); customer.AddTable(_AccountTable); NodeIterator it = new NodeIterator(customer); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(4)); AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Accounts", "Customer", "Accounts"); customer.RemoveTables(_AccountTable, _CustomerTable); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(0)); // AssertOrder(it.GetTablesRecursive(), "Customer", "Customer"); }
public void testDecodingAmpersand() { string ENCODED_WORKSHOP_TITLE = "The Testing & Refactoring Workshop"; string DECODED_WORKSHOP_TITLE = "The Testing & Refactoring Workshop"; StringBuilder decodedContent = new StringBuilder(); Parser parser = Parser.createParser(ENCODED_WORKSHOP_TITLE); parser.setNodeDecoding(true); NodeIterator nodes = parser.element(); while (nodes.hasMoreNodes()) { decodedContent.Append(nodes.nextNode().toPlainTextString()); } Assert.AreEqual(DECODED_WORKSHOP_TITLE, decodedContent.ToString(), "ampersand in string"); }
public void RunWorkFlow(string connectionString, DataConsumerPluginWrapper consumerWrapper, ExecutionResultBuilder builder, ExecutionTaskOptions options, ExecutionNode rootNode) { using (var consumer = consumerWrapper.CreateInstance()) using (iterator = new NodeIterator(rootNode)) { consumer.ReportInsertionCallback = builder.Increment; consumer.ReportErrorCallback = builder.AddError; ValueStore valueStore = new ValueStore(); DataProducer producer = new DataProducer(valueStore); builder.Begin(); consumer.Init(connectionString, consumerWrapper.OptionsTemplate); // hmm: Iterator should hold the Ienumerable and reset it when ever it starts over on a node? consumer.Consume(producer.ProduceRows(iterator.GetTablesRecursive()), valueStore); } }
public void ShouldRestartNodeCounterWhenNodeIsRestarted() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); var et = it.GetTablesRecursive().ToList(); int rowCounter = 0; et[rowCounter++].AssertNAndTable(1, "Customer"); et[rowCounter++].AssertNAndTable(1, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); // first customer, second account et[rowCounter++].AssertNAndTable(2, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); // second customer et[rowCounter++].AssertNAndTable(2, "Customer"); et[rowCounter++].AssertNAndTable(1, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); et[rowCounter++].AssertNAndTable(2, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); }
public Boolean CanMoveToEnd(Int32 lengthPath) { Int32 counter = 0; var nodeIterator = new NodeIterator(this); nodeIterator.AddActionOnMoveNext(() => counter--); while (nodeIterator.MoveNext()) { if (counter == lengthPath) { if (nodeIterator.Current.IsEnd()) { return(true); } nodeIterator.MoveBack(); } counter++; } return(counter == lengthPath); }
public void ShouldStopWhenAskedToBeCancled() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1000000); node.AddTable(new TableEntity("", "")); var tables = new List <ExecutionTable>(); NodeIterator iterator = new NodeIterator(node); Action a = new Action(() => { tables.AddRange(iterator.GetTablesRecursive()); }); a.BeginInvoke(null, null); Thread.Sleep(10); iterator.Cancel(); Console.WriteLine(tables.Count); Assert.That(tables.Count, Is.LessThan(1000000)); Assert.That(tables.Count, Is.GreaterThan(0)); }
public void ShouldBeAbleToRemoveOneTableFromExecutionNode() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(_CustomerTable); // Make 2 accounts per customer ExecutionNode accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(_AccountTable); NodeIterator it = new NodeIterator(customer); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(6)); AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Accounts", "Accounts", "Customer", "Accounts", "Accounts"); accounts.RemoveTable(_AccountTable); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(2)); AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Customer"); }
public void shouldReturnOnlyTheNodeIfOnlyOne() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); node.AddTable(new TableEntity("", "")); int counter = 0; NodeIterator it = new NodeIterator(node); Assert.That(node.Children.Count(), Is.EqualTo(0)); HashSet <TableEntity> nodes = new HashSet <TableEntity>(); foreach (var item in it.GetTablesRecursive()) { nodes.Add(item.Table); counter++; } Assert.That(counter, Is.EqualTo(1)); Assert.That(nodes.Count, Is.EqualTo(1)); }
/// <summary>Handles the iteration of the children or qualfier</summary> /// <param name="iterator">an iterator</param> /// <returns>Returns if there are more elements available.</returns> private bool IterateChildrenMethod(IIterator iterator) { if (_enclosing._skipSiblings) { // setSkipSiblings(false); _enclosing._skipSiblings = false; _subIterator = Enumerable.Empty <object>().Iterator(); } // create sub iterator for every child, // if its the first child visited or the former child is finished if (!_subIterator.HasNext() && iterator.HasNext()) { var child = (XmpNode)iterator.Next(); _index++; _subIterator = new NodeIterator(_enclosing, child, _path, _index); } if (_subIterator.HasNext()) { _returnProperty = (IXmpPropertyInfo)_subIterator.Next(); return(true); } return(false); }
public void ShouldCountTheTotalExpectedInsertedRowsInOrderToPredictProgress() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); long actualExpectedCount = it.GetExpectedInsertCount(); Assert.That(actualExpectedCount, Is.EqualTo(14)); }
public void ShouldGetAllExecutionItems() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); var child = node.AddChild(1); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); NodeIterator it = new NodeIterator(node); int counter = 0; foreach (var ei in it.GetTablesRecursive()) { Console.WriteLine(ei); counter++; } Assert.That(counter, Is.EqualTo(5)); }
public NodeCanvas(AIGraph window) : base(window) { m_nodeIterator = new NodeIterator(this); AIGraph.onControllerChanged -= SetController; AIGraph.onControllerChanged += SetController; }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { if (Source == null) return EmptyIterator.Shared; XQueryNodeIterator iter = XQueryNodeIterator.Create(Source.Execute(provider, args, pool)); for (int k = 0; k < m_filter.Length; k++) iter = new NodeIterator(CreateEnumerator(args, pool, m_filter[k], iter)); return iter; }
// each call processes one element of pattern[] bool UnifyTailEx(int ip, int it, VarStack varStack) { ListPatternElem e = (ListPatternElem)pattern[ip]; Variable rangeSpecVar = (Variable)e.RangeBindVar; NodeIterator subtreeIterator; int k; int marker; ListTerm RangeList = null; BaseTerm tail = null; int minLen; // minimum required range length (number of range elements) int maxLen; // maximum possible ... if (!DoLowerAndUpperboundChecks(ip, it, out minLen, out maxLen)) { return(false); } // scan the minimal number of range elements. Add them to the range list, // i.e. the last variable (if present) preceding the '{ , }' for (int i = 0; i < minLen; i++) { if ((k = it + i) >= target.Count) { return(false); } AppendToRangeList(ref RangeList, rangeSpecVar, target[k], ref tail); } marker = varStack.Count; // register the point to which we must possibly undo unifications if (e.HasSearchTerm) { // scan the elements up to the maximum range length, and the element immediately thereafter for (int i = minLen; i <= maxLen; i++) { BaseTerm t = null; k = it + i; if (k == target.Count) { return(false); } bool negSearchSucceeded = true; // iff none of the alternative term matches the target term for (int j = 4; j < e.Args.Length; j++) // scan all AltSearchTerm alternatives (separated by '|') { BaseTerm searchTerm = e.AltSearchTerms[j]; DownRepFactor downRepFactor = null; // e.downRepFactor [j]; t = target[k]; AltLoopStatus status = AltLoopStatus.TryNextAlt; if (downRepFactor == null) { status = TryOneAlternative(ip, varStack, e, k, marker, RangeList, i, t, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) { return(true); } } else // traverse the downRepFactor tree, which in principle may yield more than one match { subtreeIterator = new NodeIterator(t, searchTerm, downRepFactor.minLenTerm, downRepFactor.maxLenTerm, false, downRepFactor.bindVar, varStack); foreach (BaseTerm match in subtreeIterator) // try -- if necessary -- each tree match with the current search term { status = TryOneAlternative(ip, varStack, e, k, marker, RangeList, i, match, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) { return(true); } if (status == AltLoopStatus.Break) { break; } } } if (status == AltLoopStatus.Break) { break; } } // at this point sufficient alternatives have been tried if (e.IsNegSearch && negSearchSucceeded) // none of the terms matched => ok if binding succeeds { if (!TryBindingAltListVarToMatch(e.AltListBindVar, t, varStack) || // bind the AltListBindVar to the match !TryBindingRangeRelatedVars(e, i, RangeList, varStack)) // bind the range to the range variables { return(false); // binding failed } if (ip == pattern.Length - 1) // this was the last pattern element { if (k == target.Count - 1) // both pattern and target exhausted { return(true); } } else if (UnifyTailEx(ip + 1, k + 1, varStack)) // now deal with the rest { return(true); } } else if (i < maxLen) // append the rejected term to the range list and go try the next term { AppendToRangeList(ref RangeList, rangeSpecVar, t, ref tail); } } } else // a range without a subsequent search term (so followed by another range or end of pattern) { for (int i = minLen; i <= maxLen; i++) { k = it + i; if (k == target.Count) // ok, target[k] does not exist, end of target hit { return(TryBindingRangeRelatedVars(e, i, RangeList, varStack)); // i is actual range length } // k is ok if (i < maxLen) { AppendToRangeList(ref RangeList, rangeSpecVar, target[k], ref tail); } // now deal with the rest if (TryBindingRangeRelatedVars(e, i, RangeList, varStack) && UnifyTailEx(ip + 1, k, varStack)) { return(true); } } } // If we arrive here, no matching term was found in or immediately after the permitted range. // Therefore, undo any unifications made locally in this method and return with failure. if (marker != 0) { BaseTerm.UnbindToMarker(varStack, marker); } return(false); }
public override DataIterator Clone() { return(new IteratorXPath(NodeIterator.Clone(), ConvertAsCharValue)); }
private AxisIterator (AxisIterator other) : base (other) { iter = (NodeIterator) other.iter.Clone (); source = other.source; }
internal NodeIterator (NodeIterator other, bool cloneFlag) : base (other) { if (other.emptyInput) emptyInput = true; else node = other.node.Clone (); }
public override bool MoveNext() { return(NodeIterator.MoveNext()); }
public AxisIterator (NodeIterator iter, AxisStepExpr source) : base (iter.Context) { this.iter = iter; this.source = source; }
private bool CompareXML(XQueryContext context, string sourceFile, XQueryNodeIterator iter) { IXPathNavigable doc = context.OpenDocument(sourceFile); XQueryNodeIterator src = new NodeIterator(new XPathItem[] { doc.CreateNavigator() }); TreeComparer comparer = new TreeComparer(); comparer.IgnoreWhitespace = true; return comparer.DeepEqual(src, new NodeIterator(DocumentIterator(context, iter))); }
public bool MoveNext() { return(NodeIterator.MoveNext()); }
public XPathIterator Clone() { return(new XPathIterator(NodeIterator.Clone(), ConvertAsCharValue)); }
// each call processes one element of pattern[] bool UnifyTailEx (int ip, int it, VarStack varStack) { ListPatternElem e = (ListPatternElem)pattern [ip]; Variable rangeSpecVar = (Variable)e.RangeBindVar; NodeIterator subtreeIterator; int k; int marker; ListTerm RangeList = null; BaseTerm tail = null; int minLen; // minimum required range length (number of range elements) int maxLen; // maximum possible ... if (!DoLowerAndUpperboundChecks (ip, it, out minLen, out maxLen)) return false; // scan the minimal number of range elements. Add them to the range last, // i.e. the last variable (if present) preceding the '{ , }' for (int i = 0; i < minLen; i++) { if ((k = it + i) >= target.Count) return false; AppendToRangeList (ref RangeList, rangeSpecVar, target [k], ref tail); } marker = varStack.Count; // register the point to which we must possibly undo unifications if (e.HasSearchTerm) { // scan the elements up to the maximum range length, and the element immediately thereafter for (int i = minLen; i <= maxLen; i++) { BaseTerm t = null; k = it + i; if (k == target.Count) return false; bool negSearchSucceeded = true; // iff none of the alternative term matches the target term for (int j = 4; j < e.Args.Length; j++) // scan all AltSearchTerm alternatives (separated by '|') { BaseTerm searchTerm = e.AltSearchTerms [j]; DownRepFactor downRepFactor = null; // e.downRepFactor [j]; t = target [k]; AltLoopStatus status = AltLoopStatus.TryNextAlt; if (downRepFactor == null) { status = TryOneAlternative (ip, varStack, e, k, marker, RangeList, i, t, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) return true; } else // traverse the downRepFactor tree, which in principle may yield more than one match { subtreeIterator = new NodeIterator (t, searchTerm, downRepFactor.minLenTerm, downRepFactor.maxLenTerm, downRepFactor.bindVar, varStack); foreach (BaseTerm match in subtreeIterator) // try -- if necessary -- each tree match with the current search term { status = TryOneAlternative (ip, varStack, e, k, marker, RangeList, i, match, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) return true; if (status == AltLoopStatus.Break) break; } } if (status == AltLoopStatus.Break) break; } // at this point sufficient alternatives have been tried if (e.IsNegSearch && negSearchSucceeded) // none of the terms matched => ok if binding succeeds { if (!TryBindingAltListVarToMatch (e.AltListBindVar, t, varStack) || // bind the AltListBindVar to the match !TryBindingRangeRelatedVars (e, i, RangeList, varStack)) // bind the range to the range variables return false; // binding failed if (ip == pattern.Length - 1) // this was the last pattern element { if (k == target.Count - 1) // both pattern and target exhausted return true; } else if (UnifyTailEx (ip + 1, k + 1, varStack)) // now deal with the rest return true; } else if (i < maxLen) // append the rejected term to the range last and go try the next term AppendToRangeList (ref RangeList, rangeSpecVar, t, ref tail); } } else // a range without a subsequent search term (so followed by another range or end of pattern) { for (int i = minLen; i <= maxLen; i++) { k = it + i; if (k == target.Count) // ok, target[k] does not exist, end of target hit return TryBindingRangeRelatedVars (e, i, RangeList, varStack); // i is actual range length // k is ok if (i < maxLen) AppendToRangeList (ref RangeList, rangeSpecVar, target [k], ref tail); // now deal with the rest if (TryBindingRangeRelatedVars (e, i, RangeList, varStack) && UnifyTailEx (ip + 1, k, varStack)) return true; } } // If we arrive here, no matching term was found in or immediately after the permitted range. // Therefore, undo any unifications made locally in this method and return with failure. if (marker != 0) BaseTerm.UnbindToMarker (varStack, marker); return false; }
private bool CompareFragment(XQueryContext context, string sourceFile, XQueryNodeIterator iter, XmlSpace space) { StringBuilder sb = new StringBuilder(); sb.AppendLine("<?xml version='1.0'?>"); sb.Append("<root>"); TextReader textReader = new StreamReader(sourceFile, true); sb.Append(textReader.ReadToEnd()); textReader.Close(); sb.Append("</root>"); XmlReaderSettings settings = context.GetSettings(); XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()), settings); XQueryDocument doc1 = new XQueryDocument(reader, space); doc1.Fill(); context.AddDocument(doc1); XQueryDocument doc2 = context.CreateDocument(); XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc2); builder.WriteStartDocument(); builder.WriteStartElement("root", ""); Core.WriteNode(context.Engine, builder, iter.Clone()); builder.WriteEndElement(); XQueryNodeIterator iter1 = new NodeIterator(new XPathItem[] { doc1.CreateNavigator() }); XQueryNodeIterator iter2 = new NodeIterator(new XPathItem[] { doc2.CreateNavigator() }); TreeComparer comparer = new TreeComparer(); comparer.IgnoreWhitespace = true; bool res = comparer.DeepEqual(iter1, iter2); return res; }