public BufferedNodeIterator(XQueryNodeIterator src) : this(src, true) { }
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; }
public XQueryMappingIterator(object[] args, MemoryPool pool, XQueryNodeIterator iter, XQueryExprBase bodyExpr) { this.args = args; this.pool = pool; this.baseIter = iter.Clone(); this.bodyExpr = bodyExpr; provider = new ContextProvider(baseIter); }
private IEnumerable<XPathItem> DocumentIterator(XQueryContext context, XQueryNodeIterator iter) { foreach (XPathItem item in iter) { XPathNavigator nav = item as XPathNavigator; if (nav != null && nav.NodeType != XPathNodeType.Root) { XQueryDocument doc = context.CreateDocument(); XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc); builder.WriteStartDocument(); Core.WriteNode(context.Engine, builder, nav); yield return doc.CreateNavigator(); } else yield return item; } }
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))); }
private IEnumerator<XPathItem> PushIterator(ResultIterator res) { if (!res.itemSet.Completed) { XQueryNodeIterator[] iter = new XQueryNodeIterator[_path.Length]; iter[0] = res.rootIter.Clone(); if (MoveNext(res.args, res.pool, iter, _path.Length - 1)) { bool isNode = iter[_path.Length - 1].Current.IsNode; if (!isNode || res.orderedSet) { do { XPathItem curr = iter[_path.Length - 1].Current; if (curr.IsNode != isNode) throw new XQueryException(Properties.Resources.XPTY0018, curr.Value); yield return curr; } while (MoveNext(res.args, res.pool, iter, _path.Length - 1)); } else { bool needSort = false; XPathNavigator last_node = null; do { XPathItem item = iter[_path.Length - 1].Current; if (!item.IsNode) throw new XQueryException(Properties.Resources.XPTY0018, item.Value); XPathNavigator node = (XPathNavigator)item; if (!needSort) { if (last_node != null) needSort = last_node.ComparePosition(node) == XmlNodeOrder.Before; } last_node = node.Clone(); res.itemSet.Add(last_node); } while (MoveNext(res.args, res.pool, iter, _path.Length - 1)); if (needSort) res.itemSet.Sort(); res.itemSet.Completed = true; } } } if (res.itemSet.Completed) { XPathNavigator last_node = null; foreach (XPathItem item in res.itemSet) { XPathNavigator node = item as XPathNavigator; if (node != null) { if (last_node != null) { if (last_node.IsSamePosition(node)) continue; } if (!res.orderedSet) last_node = node; } yield return item; } } }
private void TraceIter(XQueryNodeIterator iter) { iter = iter.Clone(); foreach (XPathItem item in iter) { if (item.IsNode) Trace.WriteLine(((XPathNavigator)item).OuterXml); else Trace.WriteLine(item.Value); } }
public XQueryFLWORIteratorHPC(XQueryFLWOR owner, IContextProvider provider, object[] args, MemoryPool pool, XQueryNodeIterator baseIter) : base(owner, provider, args, pool, baseIter) { tasks = new ConcurrentQueue<Task<object>>(); }
public bool DeepEqual(XQueryNodeIterator iter1, XQueryNodeIterator iter2) { iter1 = iter1.Clone(); iter2 = iter2.Clone(); bool flag1; bool flag2; do { flag1 = iter1.MoveNext(); flag2 = iter2.MoveNext(); if (flag1 != flag2) return false; else if (flag1 && flag2) { if (iter1.Current.IsNode != iter2.Current.IsNode) return false; else { if (iter1.Current.IsNode && iter2.Current.IsNode) { if (!NodeEqual((XPathNavigator)iter1.Current, (XPathNavigator)iter2.Current)) return false; } else if (!ItemEqual(iter1.Current, iter2.Current)) return false; } } } while (flag1 && flag2); return true; }
protected override void Init() { index = 1; iter = baseIter.Clone(); }
public XQueryFLWORIterator(XQueryFLWOR owner, IContextProvider provider, object[] args, MemoryPool pool, XQueryNodeIterator baseIter) : base(owner, provider, args, pool, baseIter) { }
public XQueryFLWORIteratorBase(XQueryFLWOR owner, IContextProvider provider, object[] args, MemoryPool pool, XQueryNodeIterator baseIter) { this.owner = owner; this.provider = provider; this.args = args; this.pool = pool; this.baseIter = baseIter; token = owner.QueryContext.Token; }
public ItemContext(XQueryNodeIterator iter) { this.iter = iter; Context = iter.Current.Clone(); CurrentPosition = iter.CurrentPosition + 1; }
public ResultIterator(XQueryPathExpr owner, IContextProvider provider, bool orderedSet, bool parallel, XQueryNodeIterator rootIter, object[] args, MemoryPool pool) { itemSet = new ItemSet(); this.owner = owner; this.provider = provider; this.orderedSet = orderedSet; this.rootIter = rootIter; this.args = args; this.pool = pool; this.parallel = parallel; }
public BufferedNodeIterator(XQueryNodeIterator src, bool clone) { this.src = clone ? src.Clone() : src; buffer = new ItemList(); }
private IEnumerable<XPathItem> CreateEnumerator(object[] args, MemoryPool pool, XQueryExprBase expr, XQueryNodeIterator baseIter) { XQueryNodeIterator iter = baseIter.Clone(); XQueryExpr numexpr = expr as XQueryExpr; if (numexpr != null && numexpr.m_expr.Length == 1 && numexpr.m_expr[0] is Integer) { Integer pos = (Integer)numexpr.m_expr[0]; foreach (XPathItem item in iter) { if (pos == 1) { yield return item; break; } else pos--; } } else { ContextProvider provider = new ContextProvider(iter); object res = Undefined.Value; while (iter.MoveNext()) { if (m_contextSensitive || res == Undefined.Value) res = expr.Execute(provider, args, pool); if (res == Undefined.Value) { if (!m_contextSensitive) break; continue; } XQueryNodeIterator iter2 = res as XQueryNodeIterator; XPathItem item; if (iter2 != null) { iter2 = iter2.Clone(); if (!iter2.MoveNext()) continue; item = iter2.Current.Clone(); if (!item.IsNode && iter2.MoveNext()) throw new XQueryException(Properties.Resources.FORG0006, "fn:boolean()", new XQuerySequenceType(XmlTypeCode.AnyAtomicType, XmlTypeCardinality.OneOrMore)); } else { item = res as XPathItem; if (item == null) item = new XQueryItem(res); } if (item.IsNode) yield return iter.Current; else { if (ValueProxy.IsNumeric(item.ValueType)) { if (QueryContext.Engine.OperatorEq(iter.CurrentPosition + 1, item.TypedValue) != null) { yield return iter.Current; if (!m_contextSensitive) break; } } else if (Core.BooleanValue(item)) yield return iter.Current; } } } }
protected override XPathItem NextItem() { while (true) { if (childIter != null) { if (childIter.MoveNext()) { if (annotation != null) return new XQueryWrappedValue(childIter.Current, annotation); else return childIter.Current; } else childIter = null; } if (index == owner.m_expr.Length) return null; object res = owner.QueryContext.Engine.Apply(null, null, owner.m_expr[index], args, owner.m_compiledBody[index], pool); index++; if (res != Undefined.Value) { childIter = res as XQueryNodeIterator; if (childIter == null) { XPathItem item = res as XPathItem; if (item == null) { item = currItem; currItem.RawValue = res; } if (annotation != null) return new XQueryWrappedValue(item, annotation); else return item; } } } }
private bool MoveNext(object[] args, MemoryPool pool, XQueryNodeIterator[] iter, int index) { if (iter[index] != null && iter[index].MoveNext()) return true; else if (index > 0) { while (MoveNext(args, pool, iter, index - 1)) { ContextProvider provider = new ContextProvider(iter[index - 1]); if (!provider.Context.IsNode) throw new XQueryException(Properties.Resources.XPTY0019, provider.Context.Value); iter[index] = XQueryNodeIterator.Create(_path[index].Execute(provider, args, pool)); if (iter[index].MoveNext()) return true; } } return false; }