internal ChildrenQuery(
IQuery qyInput,
String name,
String prefix,
String urn,
XPathNodeType type) : base (qyInput, name, prefix, urn, type) {
}
// private XsltContext _context;
internal SortQuery(IQuery qyParent) {
System.Diagnostics.Debug.Assert(qyParent != null, "Sort Query needs an input query tree to work on");
_qyInput = qyParent;
_sortExpressions = new ArrayList();
_comparers = new ArrayList();
_Results = new SortedList(new XPathComparer(_comparers));
}
internal XPathSelfQuery(
IQuery qyInput,
String Name,
String Prefix,
String URN,
XPathNodeType Type) : base(qyInput, Name, Prefix, URN, Type) {
}
private XPathSelectionIterator(XPathSelectionIterator it) {
this.nav = it.nav.Clone();
this.query = it.query.Clone();
for(position = 0; position < it.position; position ++) {
this.query.advance();
}
}
internal override object getValue(IQuery qy) {
switch (_FuncType) {
case System.Xml.XPath.Function.FunctionType.FuncString :
return toString(qy);
case System.Xml.XPath.Function.FunctionType.FuncConcat :
return Concat(qy);
case System.Xml.XPath.Function.FunctionType.FuncStartsWith :
return Startswith(qy);
case System.Xml.XPath.Function.FunctionType.FuncContains :
return Contains(qy);
case System.Xml.XPath.Function.FunctionType.FuncSubstringBefore :
return Substringbefore(qy);
case System.Xml.XPath.Function.FunctionType.FuncSubstringAfter :
return Substringafter(qy);
case System.Xml.XPath.Function.FunctionType.FuncSubstring :
return Substring(qy);
case System.Xml.XPath.Function.FunctionType.FuncStringLength :
return StringLength(qy);
case System.Xml.XPath.Function.FunctionType.FuncNormalize :
return Normalize(qy);
case System.Xml.XPath.Function.FunctionType.FuncTranslate :
return Translate(qy);
}
return String.Empty;
}
internal MethodOperand(
IQuery opnd,
FT ftype) {
_FType= ftype;
_Opnd = opnd;
}
internal AttributeQuery(
IQuery qyParent,
String Name,
String Prefix,
String URN,
XPathNodeType Type) : base(qyParent, Name, Prefix, URN, Type) {
}
internal bool matches(IQuery e, XPathNavigator context) {
if (_opnd == null)
return false;
XPathResultType resultType = _opnd.ReturnType();
if (resultType == XPathResultType.Number){
double i = XmlConvert.ToXPathDouble(_opnd.getValue(e));
return( i == e.Position);
}
if (resultType == XPathResultType.NodeSet) {
_opnd.setContext(context);
if (_opnd.advance() != null)
return true;
else
return false;
}
if (resultType == XPathResultType.Boolean)
return Convert.ToBoolean(_opnd.getValue(e));
if (resultType == XPathResultType.String) {
if (_opnd.getValue(context, null).ToString().Length >0)
return true;
else
return false;
}
return false;
}
public XPathSelectionIterator(XPathNavigator nav, string xpath) {
this.nav = nav;
query = new QueryBuilder().Build( xpath, /*allowVar:*/true, /*allowKey:*/true );
if (query.ReturnType() != XPathResultType.NodeSet) {
throw new XPathException(Res.Xp_NodeSetExpected);
}
query.setContext(nav.Clone());
}
public XPathSelectionIterator(XPathNavigator nav, XPathExpression expr) {
this.nav = nav.Clone();
query = ((CompiledXpathExpr) expr).QueryTree;
if (query.ReturnType() != XPathResultType.NodeSet) {
throw new XPathException(Res.Xp_NodeSetExpected);
}
query.setContext(nav.Clone());
}
internal FollSiblingQuery(
IQuery qyInput,
String name,
String prefix,
String urn,
XPathNodeType type) : base (qyInput, name, prefix, urn, type)
{
}
internal XPathAncestorQuery(
IQuery qyInput,
bool matchSelf,
String Name,
String Prefix,
String URN,
XPathNodeType Type) : base(qyInput, Name, Prefix, URN, Type) {
_fMatchSelf = matchSelf;
}
internal XPathDescendantQuery(
IQuery qyParent,
bool matchSelf,
String Name,
String Prefix,
String URN,
XPathNodeType Type) : base(qyParent, Name, Prefix, URN, Type) {
_fMatchSelf = matchSelf;
}
internal SmartXPathDescendantQuery(
IQuery qyParent,
bool matchSelf,
String Name,
String Prefix,
String URN,
XPathNodeType Type,
bool abbrAxis) : base(qyParent,matchSelf, Name, Prefix, URN, Type, abbrAxis) {
}
internal XPathDescendantQuery(
IQuery qyParent,
bool matchSelf,
String Name,
String Prefix,
String URN,
XPathNodeType Type,
bool abbrAxis) : this(qyParent, matchSelf, Name, Prefix, URN, Type)
{
this.abbrAxis = abbrAxis;
}
internal NumericExpr(Operator.Op op, IQuery opnd1, IQuery opnd2) {
if ( opnd1 is VariableQuery || opnd1 is XsltFunction || opnd1.ReturnType() != XPathResultType.Number)
_opnd1= new NumberFunctions(opnd1);
else
_opnd1 = opnd1;
if (opnd2 != null && (opnd2 is VariableQuery || opnd2 is XsltFunction || opnd2.ReturnType() != XPathResultType.Number))
_opnd2= new NumberFunctions(opnd2);
else
_opnd2 = opnd2;
_op= op;
}
internal BaseAxisQuery(
IQuery qyInput,
String Name,
String Prefix,
String urn,
XPathNodeType Type) {
m_Prefix = Prefix;
m_URN = urn;
m_qyInput = qyInput;
m_Name = Name;
m_Type = Type;
_fMatchName = !m_Prefix.Equals(String.Empty) || !m_Name.Equals(String.Empty);
}
internal override object getValue(IQuery qy) {
switch (_FuncType) {
case FT.FuncNumber:
return Number(qy);
case FT.FuncSum:
return Sum(qy);
case FT.FuncFloor:
return Floor(qy);
case FT.FuncCeiling:
return Ceiling(qy);
case FT.FuncRound:
return Round(qy);
}
return null;
}
internal SortQuery(SortQuery originalQuery) {
this._qyInput = originalQuery._qyInput.Clone();
int count = originalQuery._sortExpressions.Count;
this._sortExpressions = new ArrayList(count);
for (int i=0; i < count; i++) {
IQuery query = originalQuery._sortExpressions[i] as IQuery;
query = query.Clone();
this._sortExpressions.Add(query);
}
this._comparers = new ArrayList(originalQuery._comparers);
this._Results = new SortedList(new XPathComparer(_comparers));
// SetXsltContext(_context);
}
internal override object getValue(IQuery qy) {
switch (_FuncType) {
case FT.FuncBoolean :
return toBoolean(qy);
case FT.FuncNot :
return Not(qy);
case FT.FuncTrue :
return true;
case FT.FuncFalse :
return false;
case FT.FuncLang :
return Lang(qy);
}
return null;
}
internal override void SetXsltContext(XsltContext context) {
if (context == null) {
throw new XPathException(Res.Xp_UndefinedXsltContext, Prefix, Name); }
if(xsltContextVariable == null) {
xsltContextVariable = context.ResolveVariable(Prefix, Name);
Debug.Assert(xsltContextVariable != null, "XSLT has to resolve it or throw exception");
}
else {
Debug.Assert(xsltContextVariable == context.ResolveVariable(Prefix, Name), "ResolveVariable supposed to return the same VariableAction each time");
}
Object result = xsltContextVariable.Evaluate(context);
if (result is double) {
_VarQuery = new OperandQuery(result, XPathResultType.Number);
}
else if (result is String) {
_VarQuery = new OperandQuery(result, XPathResultType.String);
}
else if (result is Boolean) {
_VarQuery = new OperandQuery(result, XPathResultType.Boolean);
}
else if (result is XPathNavigator) {
_VarQuery = new NavigatorQuery((XPathNavigator)result);
}
else if (result is ResetableIterator) {
ResetableIterator it = result as ResetableIterator;
_VarQuery = new XmlIteratorQuery( (ResetableIterator) it.Clone() );
}
else if (result is XPathNodeIterator) {
Debug.Assert(false, "Unexpected type of XPathNodeIterator");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
else if (result is int) {
_VarQuery = new OperandQuery(XmlConvert.ToXPathDouble(result), XPathResultType.Number);
}
else {
if (result == null) {
throw new XPathException(Res.Xslt_InvalidVariable, Name);
}
Debug.Assert(false, "Unexpected variable type");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
Debug.Assert(_VarQuery != null);
}
internal override object getValue( IQuery qyContext) {
double n1=0,n2=0;
//Debug.Assert(_opnd1 != null);
//Debug.Assert((_opnd2 != null) || (OperandValue::NEGATE == _op));
n1 = XmlConvert.ToXPathDouble(_opnd1.getValue(qyContext));
if (_op != Operator.Op.NEGATE)
n2 = XmlConvert.ToXPathDouble(_opnd2.getValue(qyContext));
switch (_op) {
case Operator.Op.PLUS : return n1 + n2;
case Operator.Op.MINUS : return n1 - n2;
case Operator.Op.MOD : return n1 % n2;
case Operator.Op.DIV : return n1 / n2;
case Operator.Op.MUL : return n1 * n2;
case Operator.Op.NEGATE : return -n1;
}
return null;
}
public override void AddSort(object expr, IComparer comparer) {
// sort makes sense only when we are dealing with a query that
// returns a nodeset.
IQuery evalExpr;
_allowSort = true;
if (expr is String) {
evalExpr = _builder.Build((String)expr, out _hasUnresolvedPrefix); // this will throw if expr is invalid
}
else if (expr is CompiledXpathExpr) {
evalExpr = ((CompiledXpathExpr)expr).QueryTree;
}
else {
throw new XPathException(Res.Xp_BadQueryObject);
}
if (_sortQuery == null) {
_sortQuery = new SortQuery(_compiledQuery);
_compiledQuery = _sortQuery;
}
_sortQuery.AddSort(evalExpr, comparer);
}
internal CacheQuery(IQuery qyParent) : base(qyParent){
}
private static void AddParameters(TypedParameter[] parameters, IQuery query)
{
foreach (TypedParameter parameter in parameters)
{
query.SetParameter(parameter.Name, parameter.Value,
parameter.IType);
}
}
internal IDQuery(IQuery qyInput)
{
m_qyInput = qyInput;
}
internal CompiledXpathExpr(IQuery query, string expression, bool hasPrefix) {
_compiledQuery = query;
_expr = expression;
_builder = new QueryBuilder();
_hasUnresolvedPrefix = hasPrefix;
}
internal ReversePositionQuery(IQuery qyParent) :base(qyParent){
}
internal override Object getValue(IQuery qy) {
InvokeFunction(qy.peekElement().Clone());
return _ResultQuery.getValue(qy);
}
private void InvokeFunction(XPathNavigator qy) {
IXsltContextFunction function = this.Function;
// calculate arguments:
Debug.Assert(_ArgArray != null && _ArgArray.Length == _ArgList.Count);
for(int i = _ArgList.Count - 1; 0 <= i; i --) {
IQuery arg = (IQuery) _ArgList[i];
if (arg.ReturnType() == XPathResultType.NodeSet) {
_ArgArray[i] = new XPathQueryIterator(arg, qy.Clone());
}
else {
_ArgArray[i] = arg.getValue(qy, null);
}
}
try {
object result = function.Invoke(_XsltContext, _ArgArray, qy);
if(result == null) {
_ResultQuery = new OperandQuery( String.Empty, XPathResultType.String );
}
else {
XPathResultType returnedType = function.ReturnType;
if(returnedType == XPathResultType.Any) {
// If function is untyped get returned type from real result
returnedType = XsltCompileContext.GetXPathType(result.GetType());
}
switch (returnedType) {
case XPathResultType.String :
// trick. As soon XPathResultType.Navigator will be distinct type rid of from it.
//_ResultQuery = new OperandQuery( result, XPathResultType.String );
if(result is XPathNavigator) {
_ResultQuery = new NavigatorQuery((XPathNavigator)result);
}
else {
_ResultQuery = new OperandQuery( result, XPathResultType.String );
}
break;
case XPathResultType.Boolean :
_ResultQuery = new OperandQuery( result, XPathResultType.Boolean );
break;
case XPathResultType.Number :
_ResultQuery = new OperandQuery( XmlConvert.ToXPathDouble( result ), XPathResultType.Number );
break;
case XPathResultType.NodeSet :
if (result is ResetableIterator) {
_ResultQuery = new XmlIteratorQuery((ResetableIterator)result);
}
else {
Debug.Assert(false, "Unexpected type of XPathNodeIterator");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
break;
// case XPathResultType.Navigator :
// _ResultQuery = new NavigatorQuery((XPathNavigator)result);
// break;
default :
_ResultQuery = new OperandQuery( result.ToString(), XPathResultType.String );
break;
}
}
}
catch(Exception ex) {
string qname = _Prefix != string.Empty ? _Prefix + ":" + _Name : _Name;
throw new XsltException(Res.Xslt_FunctionFailed, new string[] {qname}, ex);
}
}