Exemplo n.º 1
0
 public static double ToNumber(object arg)
 {
     if (arg == null)
     {
         throw new ArgumentNullException();
     }
     if (arg is BaseIterator || arg is XPathNavigator)
     {
         arg = XPathFunctions.ToString(arg);
     }
     if (arg is string)
     {
         string arg2 = arg as string;
         return(XPathFunctions.ToNumber(arg2));
     }
     if (arg is double)
     {
         return((double)arg);
     }
     if (arg is bool)
     {
         return(Convert.ToDouble((bool)arg));
     }
     throw new ArgumentException();
 }
 public override object Evaluate(BaseIterator iter)
 {
     if (arg0 == null)
     {
         return(XPathFunctions.ToNumber(iter.Current.Value));
     }
     return(arg0.EvaluateNumber(iter));
 }
Exemplo n.º 3
0
        public override object Evaluate(BaseIterator iter)
        {
            XPathNodeIterator xpathNodeIterator = this.arg0.EvaluateNodeSet(iter);
            double            num = 0.0;

            while (xpathNodeIterator.MoveNext())
            {
                XPathNavigator xpathNavigator = xpathNodeIterator.Current;
                num += XPathFunctions.ToNumber(xpathNavigator.Value);
            }
            return(num);
        }
        public override object Evaluate(BaseIterator iter)
        {
            XPathNodeIterator itr = arg0.EvaluateNodeSet(iter);

            double sum = 0;

            while (itr.MoveNext())
            {
                sum += XPathFunctions.ToNumber(itr.Current.Value);
            }

            return(sum);
        }
Exemplo n.º 5
0
        public virtual double EvaluateNumber(BaseIterator iter)
        {
            XPathResultType xpathResultType = this.GetReturnType(iter);
            object          obj;

            if (xpathResultType == XPathResultType.NodeSet)
            {
                obj             = this.EvaluateString(iter);
                xpathResultType = XPathResultType.String;
            }
            else
            {
                obj = this.Evaluate(iter);
            }
            if (xpathResultType == XPathResultType.Any)
            {
                xpathResultType = Expression.GetReturnType(obj);
            }
            switch (xpathResultType)
            {
            case XPathResultType.Number:
                if (obj is double)
                {
                    return((double)obj);
                }
                if (obj is IConvertible)
                {
                    return(((IConvertible)obj).ToDouble(CultureInfo.InvariantCulture));
                }
                return((double)obj);

            case XPathResultType.String:
                return(XPathFunctions.ToNumber((string)obj));

            case XPathResultType.Boolean:
                return((!(bool)obj) ? 0.0 : 1.0);

            case XPathResultType.NodeSet:
                return(XPathFunctions.ToNumber(this.EvaluateString(iter)));

            case XPathResultType.Navigator:
                return(XPathFunctions.ToNumber(((XPathNavigator)obj).Value));

            default:
                throw new XPathException("invalid node type");
            }
        }
Exemplo n.º 6
0
        public override bool EvaluateBoolean(BaseIterator iter)
        {
            XPathResultType xpathResultType  = this._left.GetReturnType(iter);
            XPathResultType xpathResultType2 = this._right.GetReturnType(iter);

            if (xpathResultType == XPathResultType.Any)
            {
                xpathResultType = Expression.GetReturnType(this._left.Evaluate(iter));
            }
            if (xpathResultType2 == XPathResultType.Any)
            {
                xpathResultType2 = Expression.GetReturnType(this._right.Evaluate(iter));
            }
            if (xpathResultType == XPathResultType.Navigator)
            {
                xpathResultType = XPathResultType.String;
            }
            if (xpathResultType2 == XPathResultType.Navigator)
            {
                xpathResultType2 = XPathResultType.String;
            }
            if (xpathResultType == XPathResultType.NodeSet || xpathResultType2 == XPathResultType.NodeSet)
            {
                Expression expression;
                Expression expression2;
                if (xpathResultType != XPathResultType.NodeSet)
                {
                    expression  = this._right;
                    expression2 = this._left;
                    XPathResultType xpathResultType3 = xpathResultType;
                    xpathResultType2 = xpathResultType3;
                }
                else
                {
                    expression  = this._left;
                    expression2 = this._right;
                }
                if (xpathResultType2 == XPathResultType.Boolean)
                {
                    return(expression.EvaluateBoolean(iter) == expression2.EvaluateBoolean(iter) == this.trueVal);
                }
                BaseIterator baseIterator = expression.EvaluateNodeSet(iter);
                if (xpathResultType2 == XPathResultType.Number)
                {
                    double num = expression2.EvaluateNumber(iter);
                    while (baseIterator.MoveNext())
                    {
                        if (XPathFunctions.ToNumber(baseIterator.Current.Value) == num == this.trueVal)
                        {
                            return(true);
                        }
                    }
                }
                else if (xpathResultType2 == XPathResultType.String)
                {
                    string b = expression2.EvaluateString(iter);
                    while (baseIterator.MoveNext())
                    {
                        if (baseIterator.Current.Value == b == this.trueVal)
                        {
                            return(true);
                        }
                    }
                }
                else if (xpathResultType2 == XPathResultType.NodeSet)
                {
                    BaseIterator baseIterator2 = expression2.EvaluateNodeSet(iter);
                    ArrayList    arrayList     = new ArrayList();
                    while (baseIterator.MoveNext())
                    {
                        XPathNavigator xpathNavigator = baseIterator.Current;
                        arrayList.Add(XPathFunctions.ToString(xpathNavigator.Value));
                    }
                    while (baseIterator2.MoveNext())
                    {
                        XPathNavigator xpathNavigator2 = baseIterator2.Current;
                        string         a = XPathFunctions.ToString(xpathNavigator2.Value);
                        for (int i = 0; i < arrayList.Count; i++)
                        {
                            if (a == (string)arrayList[i] == this.trueVal)
                            {
                                return(true);
                            }
                        }
                    }
                }
                return(false);
            }
            else
            {
                if (xpathResultType == XPathResultType.Boolean || xpathResultType2 == XPathResultType.Boolean)
                {
                    return(this._left.EvaluateBoolean(iter) == this._right.EvaluateBoolean(iter) == this.trueVal);
                }
                if (xpathResultType == XPathResultType.Number || xpathResultType2 == XPathResultType.Number)
                {
                    return(this._left.EvaluateNumber(iter) == this._right.EvaluateNumber(iter) == this.trueVal);
                }
                return(this._left.EvaluateString(iter) == this._right.EvaluateString(iter) == this.trueVal);
            }
        }
Exemplo n.º 7
0
        public override bool EvaluateBoolean(BaseIterator iter)
        {
            XPathResultType xpathResultType  = this._left.GetReturnType(iter);
            XPathResultType xpathResultType2 = this._right.GetReturnType(iter);

            if (xpathResultType == XPathResultType.Any)
            {
                xpathResultType = Expression.GetReturnType(this._left.Evaluate(iter));
            }
            if (xpathResultType2 == XPathResultType.Any)
            {
                xpathResultType2 = Expression.GetReturnType(this._right.Evaluate(iter));
            }
            if (xpathResultType == XPathResultType.Navigator)
            {
                xpathResultType = XPathResultType.String;
            }
            if (xpathResultType2 == XPathResultType.Navigator)
            {
                xpathResultType2 = XPathResultType.String;
            }
            if (xpathResultType != XPathResultType.NodeSet && xpathResultType2 != XPathResultType.NodeSet)
            {
                return(this.Compare(this._left.EvaluateNumber(iter), this._right.EvaluateNumber(iter)));
            }
            bool       fReverse = false;
            Expression expression;
            Expression expression2;

            if (xpathResultType != XPathResultType.NodeSet)
            {
                fReverse    = true;
                expression  = this._right;
                expression2 = this._left;
                XPathResultType xpathResultType3 = xpathResultType;
                xpathResultType2 = xpathResultType3;
            }
            else
            {
                expression  = this._left;
                expression2 = this._right;
            }
            if (xpathResultType2 == XPathResultType.Boolean)
            {
                bool value  = expression.EvaluateBoolean(iter);
                bool value2 = expression2.EvaluateBoolean(iter);
                return(this.Compare(Convert.ToDouble(value), Convert.ToDouble(value2), fReverse));
            }
            BaseIterator baseIterator = expression.EvaluateNodeSet(iter);

            if (xpathResultType2 == XPathResultType.Number || xpathResultType2 == XPathResultType.String)
            {
                double arg = expression2.EvaluateNumber(iter);
                while (baseIterator.MoveNext())
                {
                    if (this.Compare(XPathFunctions.ToNumber(baseIterator.Current.Value), arg, fReverse))
                    {
                        return(true);
                    }
                }
            }
            else if (xpathResultType2 == XPathResultType.NodeSet)
            {
                BaseIterator baseIterator2 = expression2.EvaluateNodeSet(iter);
                ArrayList    arrayList     = new ArrayList();
                while (baseIterator.MoveNext())
                {
                    XPathNavigator xpathNavigator = baseIterator.Current;
                    arrayList.Add(XPathFunctions.ToNumber(xpathNavigator.Value));
                }
                while (baseIterator2.MoveNext())
                {
                    XPathNavigator xpathNavigator2 = baseIterator2.Current;
                    double         arg2            = XPathFunctions.ToNumber(xpathNavigator2.Value);
                    for (int i = 0; i < arrayList.Count; i++)
                    {
                        if (this.Compare((double)arrayList[i], arg2))
                        {
                            return(true);
                        }
                    }
                }
            }
            return(false);
        }