public BufferedNodeIterator(XQueryNodeIterator src, bool clone)
{
this.src = clone ? src.Clone() : src;
buffer = new ItemList();
}
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 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;
}
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);
}
}
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;
}
}
}
}
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;
}