|
public abstract Evaluate ( |
||
| nodeIterator | ||
| return | object | |
internal bool toBoolean(XPathNodeIterator nodeIterator)
{
object result = _arg.Evaluate(nodeIterator);
if (result is XPathNodeIterator)
{
return(_arg.Advance() != null);
}
string str = result as string;
if (str != null)
{
return(toBoolean(str));
}
if (result is double)
{
return(toBoolean((double)result));
}
if (result is bool)
{
return((bool)result);
}
Debug.Assert(result is XPathNavigator, "Unknown value type");
return(true);
}
private double Number(XPathNodeIterator nodeIterator)
{
if (arg == null)
{
return(XmlConvertEx.ToXPathDouble(nodeIterator.Current.Value));
}
object argVal = arg.Evaluate(nodeIterator);
switch (GetXPathType(argVal))
{
case XPathResultType.NodeSet:
XPathNavigator value = arg.Advance();
if (value != null)
{
return(Number(value.Value));
}
break;
case XPathResultType.String:
return(Number((string)argVal));
case XPathResultType.Boolean:
return(Number((bool)argVal));
case XPathResultType.Number:
return((double)argVal);
case XPathResultType_Navigator:
return(Number(((XPathNavigator)argVal).Value));
}
return(double.NaN);
}
private XPathNavigator EvaluateArg(XPathNodeIterator context)
{
if (_arg == null)
{
return(context.Current);
}
_arg.Evaluate(context);
return(_arg.Advance());
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
return(GetValue(_op,
XmlConvertEx.ToXPathDouble(_opnd1.Evaluate(nodeIterator)),
XmlConvertEx.ToXPathDouble(_opnd2.Evaluate(nodeIterator))
));
}
public override object Evaluate(XPathNodeIterator context)
{
outputBuffer.Clear();
count = 0;
return(input.Evaluate(context)); // This is trick. IDQuery needs this value. Otherwise we would return this.
// All subclasses should and would anyway override thismethod and return this.
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
ResetCount();
Reset();
qyInput.Evaluate(nodeIterator);
return(this);
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
Operator.Op op = _op;
object val1 = _opnd1.Evaluate(nodeIterator);
object val2 = _opnd2.Evaluate(nodeIterator);
int type1 = (int)GetXPathType(val1);
int type2 = (int)GetXPathType(val2);
if (type1 < type2)
{
op = Operator.InvertOperator(op);
object valTemp = val1;
val1 = val2;
val2 = valTemp;
int typeTmp = type1;
type1 = type2;
type2 = typeTmp;
}
cmpXslt?cmp;
if (op == Operator.Op.EQ || op == Operator.Op.NE)
{
cmp = s_CompXsltE[type1][type2];
}
else
{
cmp = s_CompXsltO[type1][type2];
}
Debug.Assert(cmp != null);
return(cmp(op, val1, val2));
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
Operator.Op op = _op;
object val1 = _opnd1.Evaluate(nodeIterator);
object val2 = _opnd2.Evaluate(nodeIterator);
int type1 = (int)GetXPathType(val1);
int type2 = (int)GetXPathType(val2);
if (type1 < type2)
{
op = Operator.InvertOperator(op);
object valTemp = val1;
val1 = val2;
val2 = valTemp;
int typeTmp = type1;
type1 = type2;
type2 = typeTmp;
}
if (op == Operator.Op.EQ || op == Operator.Op.NE)
{
return(s_compXsltE[type1][type2](op, val1, val2));
}
else
{
return(s_compXsltO[type1][type2](op, val1, val2));
}
}
public override object Evaluate(XPathNodeIterator context)
{
_qyInput.Evaluate(context);
_results.Clear();
BuildResultsList();
count = 0;
return(this);
}
public override object Evaluate(XPathNodeIterator context)
{
qy1.Evaluate(context);
qy2.Evaluate(context);
_advance1 = true;
_advance2 = true;
_nextNode = null;
base.ResetCount();
return(this);
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
object n1 = opnd1.Evaluate(nodeIterator);
if (((bool)n1) == isOr)
{
return(n1);
}
return(opnd2.Evaluate(nodeIterator));
}
internal bool EvaluatePredicate()
{
object value = _cond.Evaluate(qyInput);
if (value is XPathNodeIterator)
{
return(_cond.Advance() != null);
}
if (value is string)
{
return(((string)value).Length != 0);
}
if (value is double)
{
return(((double)value) == qyInput.CurrentPosition);
}
if (value is bool)
{
return((bool)value);
}
Debug.Assert(value is XPathNavigator, "Unknown value type");
return(true);
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
base.Evaluate(nodeIterator);
while (input.Advance() != null)
{
_child.Evaluate(input);
XPathNavigator node;
while ((node = _child.Advance()) != null)
{
Insert(outputBuffer, node);
}
}
return(this);
}
private static void EvaluateKey(XPathNavigator node, Query matchExpr, string matchStr, Query useExpr, Hashtable keyTable) {
try {
if (matchExpr.MatchNode(node) == null) {
return;
}
} catch(XPathException) {
throw XsltException.Create(Res.Xslt_InvalidPattern, matchStr);
}
object result = useExpr.Evaluate(new XPathSingletonIterator(node, /*moved:*/true));
XPathNodeIterator it = result as XPathNodeIterator;
if (it != null) {
bool checkDuplicates = false;
while (it.MoveNext()) {
AddKeyValue(keyTable, /*key:*/it.Current.Value, /*value:*/node, checkDuplicates);
checkDuplicates = true;
}
} else {
String key = XmlConvert.ToXPathString(result);
AddKeyValue(keyTable, key, /*value:*/node, /*checkDuplicates:*/ false);
}
}
