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;
}
