示例#1
0
        /// <summary>
        /// Mathematical multiplication between this duration stored and the supplied
        /// duration of time (of type XSYearMonthDuration)
        /// </summary>
        /// <param name="arg">
        ///            The duration of time to multiply by </param>
        /// <returns> New XSYearMonthDuration representing the resulting duration
        ///         after the multiplication </returns>
        /// <exception cref="DynamicError"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence times(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence times(ResultSequence arg)
        {
            ResultSequence convertedRS = arg;

            if (arg.size() == 1)
            {
                Item argValue = arg.first();
                if (argValue is XSDecimal)
                {
                    convertedRS = ResultSequenceFactory.create_new(new XSDouble(argValue.StringValue));
                }
            }

            XSDouble val = (XSDouble)NumericType.get_single_type(convertedRS, typeof(XSDouble));

            if (val.nan())
            {
                throw DynamicError.nan();
            }

            if (val.infinite())
            {
                throw DynamicError.overflowDateTime();
            }

            int res = (int)Math.Round(monthValue() * val.double_value());

            return(ResultSequenceFactory.create_new(new XSYearMonthDuration(res)));
        }
示例#2
0
        /// <summary>
        /// Unary operation on the arguments.
        /// </summary>
        /// <param name="args">
        ///            input arguments. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of the operation. </returns>
        public static ResultSequence fs_plus_unary(ICollection args)
        {
            // make sure we got only one arg
            if (args.Count != 1)
            {
                DynamicError.throw_type_error();
            }
            var i = args.GetEnumerator();

            i.MoveNext();
            ResultSequence arg = (ResultSequence)i.Current;

            // make sure we got only one numeric atom
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }
            Item at = arg.first();

            if (!(at is NumericType))
            {
                DynamicError.throw_type_error();
            }

            // no-op
            return(arg);
        }
示例#3
0
        /// <summary>
        /// Converts arguments to values.
        /// </summary>
        /// <param name="args">
        ///            Result from expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of conversion. </returns>
        private static ICollection value_convert_args(ICollection args)
        {
            var result = new ArrayList(args.Count);

            // atomize arguments
            for (IEnumerator i = args.GetEnumerator(); i.MoveNext();)
            {
                ResultSequence rs = (ResultSequence)i.Current;

                //FnData.fast_atomize(rs);
                rs = FnData.atomize(rs);

                if (rs.empty())
                {
                    return(new ArrayList());
                }

                if (rs.size() > 1)
                {
                    throw new DynamicError(TypeError.invalid_type(null));
                }

                Item arg = rs.first();

                if (arg is XSUntypedAtomic)
                {
                    arg = new XSString(arg.StringValue);
                }

                result.Add(arg);
            }

            return(result);
        }
示例#4
0
        /// <summary>
        /// Deep-Equal boolean operation.
        /// </summary>
        /// <param name="one">
        ///            input1 xpath expression/variable. </param>
        /// <param name="two">
        ///            input2 xpath expression/variable. </param>
        /// <param name="context">
        ///            Current dynamic context </param>
        /// <returns> Result of fn:deep-equal operation. </returns>
        public static bool deep_equal(ResultSequence one, ResultSequence two, EvaluationContext context, string collationURI)
        {
            if (one.empty() && two.empty())
            {
                return(true);
            }

            if (one.size() != two.size())
            {
                return(false);
            }

            var onei = one.iterator();
            var twoi = two.iterator();

            while (onei.MoveNext())
            {
                AnyType a = (AnyType)onei.Current;
                twoi.MoveNext();
                AnyType b = (AnyType)twoi.Current;

                if (!deep_equal(a, b, context, collationURI))
                {
                    return(false);
                }
            }
            return(true);
        }
示例#5
0
        /// <summary>
        /// Mathematical subtraction between this time stored and the supplied
        /// representation. This supplied representation must be of either type
        /// XSTime (in which case the result is the duration of time between these
        /// two times) or a XSDayTimeDuration (in which case the result is the time
        /// when this duration is subtracted from the time stored).
        /// </summary>
        /// <param name="arg">
        ///            The representation to subtract (either XSTim or
        ///            XDTDayTimeDuration) </param>
        /// <returns> A ResultSequence representing the result of the subtraction </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence minus(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence minus(ResultSequence arg)
        {
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg.first();

            if (!(at is XSTime) && !(at is XSDayTimeDuration))
            {
                throw DynamicError.throw_type_error();
            }

            if (at is XSTime)
            {
                return(minusXSTimeDuration(at));
            }

            if (at is XSDayTimeDuration)
            {
                return(minusXSDayTimeDuration(at));
            }
            return(null);            // unreach
        }
示例#6
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void considerSequence(org.eclipse.wst.xml.xpath2.api.ResultSequence sequenceToConsider) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual void considerSequence(ResultSequence sequenceToConsider)
        {
            for (int i = 0; i < sequenceToConsider.size(); ++i)
            {
                Item item = sequenceToConsider.item(i);
                considerValue(item);
            }
        }
示例#7
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected org.eclipse.wst.xml.xpath2.api.Item get_single_arg(org.eclipse.wst.xml.xpath2.api.ResultSequence rs) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        protected internal virtual Item get_single_arg(ResultSequence rs)
        {
            if (rs.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            return(rs.first());
        }
示例#8
0
        // voodoo 2
        /// <summary>
        /// Actual equality operation for fs_eq_value.
        /// </summary>
        /// <param name="args">
        ///            input arguments. </param>
        /// <param name="type">
        ///            type of the arguments. </param>
        /// <param name="mname">
        ///            Method name for template simulation. </param>
        /// <param name="dynamicContext">
        ///             Dynamic error. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of the operation. </returns>
        public static ResultSequence do_cmp_value_op(ICollection args, Type type, string mname, DynamicContext context)
        {
            // sanity check args + convert em
            if (args.Count != 2)
            {
                DynamicError.throw_type_error();
            }

            ICollection cargs = value_convert_args(args);

            if (cargs.Count == 0)
            {
                return(ResultBuffer.EMPTY);
            }

            // make sure arugments are comparable by equality
            IEnumerator argi = cargs.GetEnumerator();

            argi.MoveNext();
            Item arg = ((ResultSequence)argi.Current).first();

            argi.MoveNext();
            ResultSequence arg2 = (ResultSequence)argi.Current;

            if (arg2.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            if (!(type.IsInstanceOfType(arg)))
            {
                DynamicError.throw_type_error();
            }
            try
            {
                Type[]   margsdef  = new Type[] { type };
                Type[]   margsdef2 = new Type[] { typeof(AnyType), typeof(DynamicContext) };
                object[] margs3    = new object[] { mname, margsdef2 };
                var      v1        = typeof(GenericIComparer)
                                     .GetMethod("GetComparer");
                var v2     = v1.MakeGenericMethod(margsdef);
                var method = (MethodBase)v2.Invoke(null, margs3);

                object[] margs = new object[] { arg2.first(), context };

                object[] real_args = new object[] { arg, margs };

                bool cmpres = (bool)method.Invoke(arg, margs);

                return(ResultSequenceFactory.create_new(new XSBoolean(cmpres)));
            }
            catch
            {
                Debug.Assert(false);
                throw new Exception("cannot compare using method " + mname);
            }
        }
示例#9
0
        /// <summary>
        /// Mathematical addition operator between this XSDate and a supplied result
        /// sequence (XDTYearMonthDuration and XDTDayTimeDuration are only valid
        /// ones).
        /// </summary>
        /// <param name="arg">
        ///            The supplied ResultSequence that is on the right of the minus
        ///            operator. If arg is an XDTYearMonthDuration or an
        ///            XDTDayTimeDuration the result will be a XSDate of the result
        ///            of the current date minus the duration of time supplied. </param>
        /// <returns> New ResultSequence consisting of the result of the mathematical
        ///         minus operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence plus(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence plus(ResultSequence arg)
        {
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg.first();

            try
            {
                if (at is XSYearMonthDuration)
                {
                    XSYearMonthDuration val = (XSYearMonthDuration)at;

                    XSDate res = (XSDate)clone();

                    res.calendar().add(Calendar.MONTH, val.monthValue());
                    return(ResultSequenceFactory.create_new(res));
                }
                else if (at is XSDayTimeDuration)
                {
                    XSDayTimeDuration val = (XSDayTimeDuration)at;

                    XSDate res = (XSDate)clone();

                    // We only need to add the Number of days dropping the rest.
                    int days = val.days();
                    if (val.negative())
                    {
                        days *= -1;
                    }
                    res.calendar().add(Calendar.DAY_OF_MONTH, days);

                    res.calendar().add(Calendar.MILLISECOND,
                                       (int)(val.time_value() * 1000.0));
                    return(ResultSequenceFactory.create_new(res));
                }
                else
                {
                    DynamicError.throw_type_error();
                    return(null);                    // unreach
                }
            }
            catch
            {
                Debug.Assert(false);
                return(null);
            }
        }
示例#10
0
        /// <summary>
        /// Mathematical division between this duration stored and the supplied
        /// duration of time (of type XSYearMonthDuration)
        /// </summary>
        /// <param name="arg">
        ///            The duration of time to divide by </param>
        /// <returns> New XSYearMonthDuration representing the resulting duration
        ///         after the division </returns>
        /// <exception cref="DynamicError"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence div(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence div(ResultSequence arg)
        {
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg.first();

            if (at is XSDouble)
            {
                XSDouble dt = (XSDouble)at;

                int ret = 0;

                if (!dt.zero())
                {
                    ret = (int)Math.Round(monthValue() / dt.double_value());
                }

                return(ResultSequenceFactory.create_new(new XSYearMonthDuration(ret)));
            }
            else if (at is XSDecimal)
            {
                XSDecimal dt = (XSDecimal)at;

                int ret = 0;

                if (!dt.zero())
                {
                    ret = (int)Math.Round(monthValue() / dt.Value);
                }

                return(ResultSequenceFactory.create_new(new XSYearMonthDuration(ret)));
            }
            else if (at is XSYearMonthDuration)
            {
                XSYearMonthDuration md = (XSYearMonthDuration)at;

                double res = (double)monthValue() / md.monthValue();

                return(ResultSequenceFactory.create_new(new XSDecimal(new decimal(res))));
            }
            else
            {
                DynamicError.throw_type_error();
                return(null);                // unreach
            }
        }
示例#11
0
        /// <summary>
        /// Reverse the arguments.
        /// </summary>
        /// <param name="args">
        ///            are reversed. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> The result of the reversal of the arguments. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence reverse(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence reverse(ICollection args)
        {
            Debug.Assert(args.Count == 1);

            // get args
            IEnumerator citer = args.GetEnumerator();

            citer.MoveNext();
            ResultSequence arg = (ResultSequence)citer.Current;

            if (arg.size() <= 1)
            {
                return(arg);
            }

            ResultBuffer rs = new ResultBuffer();

            for (int i = arg.size() - 1; i >= 0; --i)
            {
                rs.add(arg.item(i));
            }

            return(rs.Sequence);
        }
示例#12
0
        /// <summary>
        ///*
        /// Check whether first node in supplied ResultSequence is of the supplied
        /// type
        /// </summary>
        /// <param name="rs">
        ///            The node being tested </param>
        /// <param name="type">
        ///            The type expected </param>
        /// <returns> The node being tested </returns>
        /// <exception cref="DynamicError">
        ///             If node being tested is not of expected type </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static AnyType get_single_type(org.eclipse.wst.xml.xpath2.api.ResultSequence rs, Class type) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static AnyType get_single_type(ResultSequence rs, Type type)
        {
            if (rs.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = rs.first();

            if (!type.IsInstanceOfType(at))
            {
                DynamicError.throw_type_error();
            }

            return((AnyType)at);
        }
示例#13
0
        // XXX IN GENRAL, I THIUNK WE NEED TO PULL SANITY CHECKING OUTSIDE!
        // PLUS I AM NOT ATOMIZING/ETC ETC HERE!!! BAD CODE
        // BUG XXX HACK DEATH
        /// <summary>
        /// Evaluate arguments.
        /// </summary>
        /// <param name="args">
        ///            argument expressions. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of evaluation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence evaluate(java.util.Collection args, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence evaluate(ICollection args, EvaluationContext ec)
        {
            Debug.Assert(args.Count >= min_arity() && args.Count <= max_arity());
            var i = args.GetEnumerator();

            i.MoveNext();
            // sanity checks
            ResultSequence arg = (ResultSequence)i.Current;

            if (arg == null || arg.size() > 1)
            {
                DynamicError.throw_type_error();
            }

            // do it
            return(_atomic_type.constructor(arg));
        }
示例#14
0
        /// <summary>
        /// Exactly-one operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:exactly-one operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence exactly_one(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence exactly_one(ICollection args)
        {
            Debug.Assert(args.Count == 1);

            // get args
            IEnumerator citer = args.GetEnumerator();

            citer.MoveNext();
            ResultSequence arg = (ResultSequence)citer.Current;

            if (arg == null || arg.size() != 1)
            {
                throw DynamicError.not_one(null);
            }

            return(arg);
        }
示例#15
0
        /// <summary>
        /// Mathematical addition operator between this XSDateTime and a supplied
        /// result sequence (XDTYearMonthDuration and XDTDayTimeDuration are only
        /// valid ones).
        /// </summary>
        /// <param name="arg">
        ///            The supplied ResultSequence that is on the right of the minus
        ///            operator. If arg is an XDTYearMonthDuration or an
        ///            XDTDayTimeDuration the result will be a XSDateTime of the
        ///            result of the current date minus the duration of time
        ///            supplied. </param>
        /// <returns> New ResultSequence consisting of the result of the mathematical
        ///         minus operation. </returns>
        public virtual ResultSequence plus(ResultSequence arg)
        {
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg.first();

            try
            {
                if (at is XSYearMonthDuration)
                {
                    XSYearMonthDuration val = (XSYearMonthDuration)at;

                    XSDateTime res = (XSDateTime)clone();

                    res.calendar().add(Calendar.MONTH, val.monthValue());
                    return(ResultSequenceFactory.create_new(res));
                }
                else if (at is XSDayTimeDuration)
                {
                    XSDuration val = (XSDuration)at;

                    XSDateTime res = (XSDateTime)clone();

                    XMLGregorianCalendar xmlCal     = _datatypeFactory.newXMLGregorianCalendar((GregorianCalendar)calendar());
                    Duration             dtduration = _datatypeFactory.newDuration(val.StringValue);
                    xmlCal.add(dtduration);
                    res = new XSDateTime(xmlCal.toGregorianCalendar(), res.tz());
                    return(ResultSequenceFactory.create_new(res));
                }
                else
                {
                    DynamicError.throw_type_error();
                    return(null);                    // unreach
                }
            }
            catch
            {
                Debug.Assert(false);
                return(null);
            }
        }
示例#16
0
        /// <summary>
        /// Concatenate the arguments.
        /// </summary>
        /// <param name="args">
        ///            are concatenated. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> The result of the concatenation of the arguments. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence concat(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence concat(ICollection args)
        {
            // sanity check
            if (args.Count < 2)
            {
                DynamicError.throw_type_error();
            }

            ResultBuffer rs = new ResultBuffer();

            string result = "";

            // go through args
            StringBuilder buf = new StringBuilder();

            for (IEnumerator argi = args.GetEnumerator(); argi.MoveNext();)
            {
                ResultSequence arg = (ResultSequence)argi.Current;

                int size = arg.size();

                // sanity check
                if (size > 1)
                {
                    DynamicError.throw_type_error();
                }

                if (size == 0)
                {
                    continue;
                }

                Item at = arg.first();

                buf.Append(at.StringValue);
            }
            result = buf.ToString();

            rs.add(new XSString(result));

            return(rs.Sequence);
        }
示例#17
0
        /// <summary>
        /// Codepoints to string operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:codepoints-to-string operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence codepoints_to_string(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence codepoints_to_string(ICollection args)
        {
            ICollection cargs = Function.convert_arguments(args, expected_args());
            var         j     = cargs.GetEnumerator();

            j.MoveNext();
            ResultSequence arg1 = (ResultSequence)j.Current;

            if (arg1 == null || arg1.empty())
            {
                return(new XSString(""));
            }

            int[] codePointArray = new int[arg1.size()];
            int   codePointIndex = 0;

            for (var i = arg1.iterator(); i.MoveNext();)
            {
                XSInteger code = (XSInteger)i.Current;

                int codepoint = (int)code.int_value();
                if (codepoint < MIN_LEGAL_CODEPOINT || codepoint > MAX_LEGAL_CODEPOINT)
                {
                    throw DynamicError.unsupported_codepoint("U+" + Convert.ToString(codepoint, 16).ToUpper());
                }

                codePointArray[codePointIndex] = codepoint;
                codePointIndex++;
            }

            try
            {
                var    c   = codePointArray.Select(x => (char)x).ToArray();
                string str = new string(c);
                return(new XSString(str));
            }
            catch (System.ArgumentException iae)
            {
                // This should be duoble checked above, but rather safe than sorry
                throw DynamicError.unsupported_codepoint(iae.Message);
            }
        }
示例#18
0
        /// <summary>
        /// Trace operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:trace operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence trace(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence trace(ICollection args)
        {
            // sanity check args
            if (args.Count != 2)
            {
                DynamicError.throw_type_error();
            }

            IEnumerator argsi = args.GetEnumerator();

            argsi.MoveNext();
            ResultSequence arg1 = (ResultSequence)argsi.Current;

            argsi.MoveNext();
            ResultSequence arg2 = (ResultSequence)argsi.Current;

            if (arg2 == null || arg2.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg2.first();

            if (!(at is XSString))
            {
                DynamicError.throw_type_error();
            }

            XSString label = (XSString)at;

            int index = 1;

            for (var i = arg1.iterator(); i.MoveNext(); index++)
            {
                at = (AnyType)i.Current;

                Console.WriteLine(label.value() + " [" + index + "] " + ((AnyType)at).string_type() + ":" + at.StringValue);
            }

            return(arg1);
        }
示例#19
0
        /// <summary>
        /// String operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:string operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence string(java.util.Collection args, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence @string(ICollection args, EvaluationContext ec)
        {
            Debug.Assert(args.Count == 0 || args.Count == 1);

            ResultSequence arg1 = null;

            if (args.Count == 0)
            {
                // support for arity = 0
                return(getResultSetForArityZero(ec));
            }
            else
            {
                var i = args.GetEnumerator();
                i.MoveNext();
                arg1 = (ResultSequence)i.Current;
            }

            // sanity check args
            if (arg1.size() > 1)
            {
                throw new DynamicError(TypeError.invalid_type(null));
            }

            ResultBuffer rs = new ResultBuffer();

            if (arg1.empty())
            {
                rs.add(new XSString(""));
            }
            else
            {
                Item at = arg1.first();
                rs.add(new XSString(at.StringValue));
            }

            return(rs.Sequence);
        }
示例#20
0
        /// <summary>
        /// Evaluate arguments.
        /// </summary>
        /// <param name="args">
        ///            argument expressions. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of evaluation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence evaluate(java.util.Collection args, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence evaluate(ICollection args, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec)
        {
            IEnumerator argIterator = args.GetEnumerator();

            argIterator.MoveNext();
            ResultSequence argSequence = (ResultSequence)argIterator.Current;
            AnyAtomicType  zero        = ZERO;

            if (argIterator.MoveNext())
            {
                ResultSequence zeroSequence = (ResultSequence)argIterator.Current;
                if (zeroSequence.size() != 1)
                {
                    throw new DynamicError(TypeError.invalid_type(null));
                }
                if (!(zeroSequence.first() is AnyAtomicType))
                {
                    throw new DynamicError(TypeError.invalid_type(zeroSequence.first().StringValue));
                }
                zero = (AnyAtomicType)zeroSequence.first();
            }
            return(sum(argSequence, zero));
        }
示例#21
0
        /// <summary>
        /// Mathematical multiplication between this duration stored and the supplied
        /// duration of time (of type XSDayTimeDuration)
        /// </summary>
        /// <param name="arg">
        ///            The duration of time to multiply by </param>
        /// <returns> New XSDayTimeDuration representing the resulting duration after
        ///         the multiplication </returns>
        /// <exception cref="DynamicError"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence times(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence times(ResultSequence arg)
        {
            ResultSequence convertedRS = arg;

            if (arg.size() == 1)
            {
                Item argValue = arg.first();
                if (argValue is XSDecimal)
                {
                    convertedRS = ResultSequenceFactory.create_new(new XSDouble(argValue.StringValue));
                }
            }

            XSDouble val = (XSDouble)NumericType.get_single_type(convertedRS, typeof(XSDouble));

            if (val.nan())
            {
                throw DynamicError.nan();
            }

            double res = value() * val.double_value();

            return(ResultSequenceFactory.create_new(new XSDayTimeDuration(res)));
        }
示例#22
0
        /// <summary>
        /// Obtain numeric value from expression.
        /// </summary>
        /// <param name="arg">
        ///            input expression. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Resulting numeric type from the operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.processor.internal.types.NumericType get_single_numeric_arg(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static NumericType get_single_numeric_arg(ResultSequence arg)
        {
            int size = arg.size();

            if (size > 1)
            {
                DynamicError.throw_type_error();
            }

            if (size == 0)
            {
                return(null);
            }

            arg = FnData.atomize(arg);
            AnyType at = (AnyType)arg.item(0);

            if (!(at is NumericType))
            {
                throw DynamicError.invalidType();
            }

            return((NumericType)at);
        }
示例#23
0
        /// <summary>
        /// Convert and promote arguments for operation.
        /// </summary>
        /// <param name="args">
        ///            input arguments. </param>
        /// <param name="sc"> </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of conversion. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private static java.util.Collection convert_args(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        private static ICollection convert_args(ICollection args)
        {
            var result = new ArrayList();

            // Keep track of numeric types for promotion
            bool has_float  = false;
            bool has_double = false;

            // atomize arguments
            for (IEnumerator i = args.GetEnumerator(); i.MoveNext();)
            {
                ResultSequence rs = FnData.atomize((ResultSequence)i.Current);

                if (rs.empty())
                {
                    return(new ArrayList());
                }

                if (rs.size() > 1)
                {
                    throw new DynamicError(TypeError.invalid_type(null));
                }

                AnyType arg = (AnyType)rs.item(0);

                if (arg is XSUntypedAtomic)
                {
                    arg = new XSDouble(arg.StringValue);
                }

                if (arg is XSDouble)
                {
                    has_double = true;
                }
                if (arg is XSFloat)
                {
                    has_float = true;
                }
                result.Add(ResultBuffer.wrap(arg));
            }

            if (has_double)
            {
                has_float = false;
            }

            if (has_double || has_float)
            {
                var result2 = new ArrayList();

                // promote arguments
                for (IEnumerator i = result.GetEnumerator(); i.MoveNext();)
                {
                    ResultSequence rs = (ResultSequence)i.Current;

                    Item arg = rs.item(0);

                    if (has_double && (arg is XSFloat))
                    {
                        arg = new XSDouble(((XSFloat)arg).float_value());
                    }
                    else if (has_double && (arg is XSDecimal))
                    {
                        arg = new XSDouble(((XSDecimal)arg).double_value());
                    }
                    else if (has_float && (arg is XSDecimal))
                    {
                        arg = new XSFloat((float)((XSDecimal)arg).double_value());
                    }
                    result2.Add(arg);
                }
                return(result2);
            }

            return(result);
        }
示例#24
0
        /// <summary>
        /// Insert-Before operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:insert-before operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence insert_before(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence insert_before(ICollection args)
        {
            Debug.Assert(args.Count == 3);

            ResultBuffer rs = new ResultBuffer();

            // get args
            IEnumerator citer = args.GetEnumerator();

            citer.MoveNext();
            ResultSequence target = (ResultSequence)citer.Current;

            citer.MoveNext();
            ResultSequence arg2 = (ResultSequence)citer.Current;

            citer.MoveNext();
            ResultSequence inserts = (ResultSequence)citer.Current;

            // sanity chex
            if (arg2.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg2.first();

            if (!(at is XSInteger))
            {
                DynamicError.throw_type_error();
            }

            // XXX cloning!
            if (target.empty())
            {
                return(inserts);
            }
            if (inserts.empty())
            {
                return(target);
            }

            int position = (int)((XSInteger)at).int_value();

            if (position < 1)
            {
                position = 1;
            }
            int target_size = target.size();

            if (position > target_size)
            {
                position = target_size + 1;
            }

            int curpos = 1;

            for (var i = target.iterator(); i.MoveNext();)
            {
                at = (AnyType)i.Current;

                if (curpos == position)
                {
                    rs.concat(inserts);
                }

                rs.add(at);

                curpos++;
            }
            if (curpos == position)
            {
                rs.concat(inserts);
            }

            return(rs.Sequence);
        }
示例#25
0
 /// <returns> size </returns>
 public override int size()
 {
     return(_size + _tail.size());
 }
示例#26
0
        /// <summary>
        /// Number operation.
        /// </summary>
        /// <param name="arg">
        ///            Result from the expressions evaluation. </param>
        /// <param name="dc">
        ///            Result of dynamic context operation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:number operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.processor.internal.types.XSDouble fn_number(org.eclipse.wst.xml.xpath2.api.ResultSequence arg, org.eclipse.wst.xml.xpath2.api.EvaluationContext ec) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static XSDouble fn_number(ResultSequence arg, EvaluationContext ec)
        {
            if (arg.size() > 1)
            {
                throw new DynamicError(TypeError.invalid_type("bad argument passed to fn:number()"));
            }
            else if (arg.size() == 1)
            {
                Item at = arg.first();

                /*
                 * if (!(at instanceof AnyAtomicType))
                 *      DynamicError.throw_type_error();
                 */

                if (at is AnyAtomicType)
                {
                    if ((at is XSDouble))
                    {
                        return((XSDouble)at);
                    }
                    else if ((at is XSFloat))
                    {
                        float value = ((XSFloat)at).float_value();
                        if (float.IsNaN(value))
                        {
                            return(new XSDouble(double.NaN));
                        }
                        else if (value == float.NegativeInfinity)
                        {
                            return(new XSDouble(double.NegativeInfinity));
                        }
                        else if (value == float.PositiveInfinity)
                        {
                            return(new XSDouble(double.PositiveInfinity));
                        }
                        else
                        {
                            return(new XSDouble((double)value));
                        }
                    }
                    else
                    {
                        XSDouble d = XSDouble.parse_double(at.StringValue);
                        return(d != null ? d : new XSDouble(double.NaN));
                    }
                }
                else if (at is NodeType)
                {
                    XSDouble d = XSDouble.parse_double((FnData.atomize(at)).StringValue);
                    return(d != null ? d : new XSDouble(double.NaN));
                }
            }
            else
            {
                return(new XSDouble(double.NaN));
            }

            // unreach
            return(null);
        }
示例#27
0
        /// <summary>
        /// Count operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:count operation. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.api.ResultSequence count(java.util.Collection args) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static ResultSequence count(ICollection args)
        {
            Debug.Assert(args.Count == 1);

            // get args
            IEnumerator citer = args.GetEnumerator();

            citer.MoveNext();
            ResultSequence arg = (ResultSequence)citer.Current;

            return(ResultSequenceFactory.create_new(new XSInteger(new System.Numerics.BigInteger(arg.size()))));
        }
示例#28
0
        /// <summary>
        /// Boolean operation.
        /// </summary>
        /// <param name="arg">
        ///            Result from the expressions evaluation. </param>
        /// <returns> Result of fn:boolean operation. </returns>
        /// <exception cref="DynamicError">  </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static org.eclipse.wst.xml.xpath2.processor.internal.types.XSBoolean fn_boolean(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public static XSBoolean fn_boolean(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(XSBoolean.FALSE);
            }

            Item at = arg.item(0);

            if (at is CalendarType)
            {
                throw DynamicError.throw_type_error();
            }

            if (at is NodeType)
            {
                return(XSBoolean.TRUE);
            }

            if (arg.size() > 1)
            {
                throw DynamicError.throw_type_error();
            }

            // XXX ??
            if (!(at is AnyAtomicType))
            {
                return(XSBoolean.TRUE);
            }

            // ok we got 1 single atomic type element

            if (at is XSBoolean)
            {
                if (!((XSBoolean)at).value())
                {
                    return(XSBoolean.FALSE);
                }
            }

            if ((at is XSString) || (at is XSUntypedAtomic))
            {
                if (((AnyType)at).StringValue.Equals(""))
                {
                    return(XSBoolean.FALSE);
                }
            }

            if (at is NumericType)
            {
                if (((NumericType)at).zero())
                {
                    return(XSBoolean.FALSE);
                }
            }

            if ((at is XSFloat) && (((XSFloat)at).nan()))
            {
                return(XSBoolean.FALSE);
            }

            if ((at is XSDouble) && (((XSDouble)at).nan()))
            {
                return(XSBoolean.FALSE);
            }


            return(XSBoolean.TRUE);
        }
示例#29
0
        /// <summary>
        /// Index-Of operation.
        /// </summary>
        /// <param name="args">
        ///            Result from the expressions evaluation. </param>
        /// <param name="dynamicContext"> </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Result of fn:index-of operation. </returns>
        public static ResultSequence index_of(ICollection args, DynamicContext dc)
        {
            Function.convert_arguments(args, expected_args());

            // get args
            IEnumerator citer = args.GetEnumerator();

            citer.MoveNext();
            ResultSequence arg1 = (ResultSequence)citer.Current;

            citer.MoveNext();
            ResultSequence arg2 = (ResultSequence)citer.Current;

            if (arg1 == null || arg1.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            // sanity chex
            if (arg2 == null || arg2.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            string collationUri = dc.CollationProvider.DefaultCollation;

            if (citer.MoveNext())
            {
                ResultSequence arg3 = (ResultSequence)citer.Current;
                if (!arg3.empty())
                {
                    XSString collation = (XSString)arg3.first();
                    collationUri = collation.StringValue;
                }
            }

            ResultBuffer  rb = new ResultBuffer();
            AnyAtomicType at = (AnyAtomicType)arg2.first();

            get_comparable(at);

            int index = 1;

            for (var i = arg1.iterator(); i.MoveNext();)
            {
                AnyType cmptype = (AnyType)i.Current;
                get_comparable(cmptype);

                if (!(at is CmpEq))
                {
                    continue;
                }

                if (isBoolean(cmptype, at))
                {
                    XSBoolean boolat = (XSBoolean)cmptype;
                    if (boolat.eq(at, dc))
                    {
                        rb.add(new XSInteger(new System.Numerics.BigInteger(index)));
                    }
                }
                else
                {
                    if (isNumeric(cmptype, at))
                    {
                        NumericType numericat = (NumericType)at;
                        if (numericat.eq(cmptype, dc))
                        {
                            rb.add(new XSInteger(new System.Numerics.BigInteger(index)));
                        }
                    }
                    else
                    {
                        if (isDuration(cmptype, at))
                        {
                            XSDuration durat = (XSDuration)at;
                            if (durat.eq(cmptype, dc))
                            {
                                rb.add(new XSInteger(new System.Numerics.BigInteger(index)));
                            }
                        }
                        else
                        {
                            if (at is QName && cmptype is QName)
                            {
                                QName qname = (QName)at;
                                if (qname.eq(cmptype, dc))
                                {
                                    rb.add(new XSInteger(new System.Numerics.BigInteger(index)));
                                }
                            }
                            else
                            {
                                if (needsStringComparison(cmptype, at))
                                {
                                    XSString xstr1   = new XSString(cmptype.StringValue);
                                    XSString itemStr = new XSString(at.StringValue);
                                    if (FnCompare.compare_string(collationUri, xstr1, itemStr, dc).Equals(System.Numerics.BigInteger.Zero))
                                    {
                                        rb.add(new XSInteger(new System.Numerics.BigInteger(index)));
                                    }
                                }
                            }
                        }
                    }
                }

                index++;
            }

            return(rb.Sequence);
        }
示例#30
0
        /// <summary>
        /// Mathematical division between this duration stored and the supplied
        /// duration of time (of type XSDayTimeDuration)
        /// </summary>
        /// <param name="arg">
        ///            The duration of time to divide by </param>
        /// <returns> New XSDayTimeDuration representing the resulting duration after
        ///         the division </returns>
        /// <exception cref="DynamicError"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence div(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public virtual ResultSequence div(ResultSequence arg)
        {
            if (arg.size() != 1)
            {
                DynamicError.throw_type_error();
            }

            Item at = arg.first();

            if (at is XSDouble)
            {
                XSDouble dt     = (XSDouble)at;
                double   retval = 0;

                if (dt.nan())
                {
                    throw DynamicError.nan();
                }

                if (!dt.zero())
                {
                    decimal ret = new decimal(0);

                    if (dt.infinite())
                    {
                        retval = value() / dt.double_value();
                    }
                    else
                    {
                        ret = new decimal(value());
                        ret = decimal.Divide(ret, new decimal(dt.double_value()));
                        var x = ret.ToString();
                        double.TryParse(x, out double r);
                        retval = r;
                    }
                }
                else
                {
                    throw DynamicError.overflowUnderflow();
                }

                return(ResultSequenceFactory.create_new(new XSDayTimeDuration(retval)));
            }
            else if (at is XSDecimal)
            {
                XSDecimal dt = (XSDecimal)at;

                decimal ret = new decimal(0);

                if (!dt.zero())
                {
                    ret = new decimal(value());
                    ret = decimal.Divide(ret, dt.Value);
                }
                else
                {
                    throw DynamicError.overflowUnderflow();
                }

                var x = ret.ToString();
                double.TryParse(x, out double r);
                var i = (int)r;
                return(ResultSequenceFactory.create_new(new XSDayTimeDuration(i)));
            }
            else if (at is XSDayTimeDuration)
            {
                XSDuration md = (XSDuration)at;

                decimal res = default;
                res = new decimal(this.value());
                decimal l = new decimal(md.value());
                res = decimal.Divide(res, l);

                return(ResultSequenceFactory.create_new(new XSDecimal(res)));
            }
            else
            {
                DynamicError.throw_type_error();
                return(null);                // unreach
            }
        }