Exemplo n.º 1
0
        /// <summary>
        /// Creates a new ResultSequence consisting of the extractable unsignedByte
        /// in the supplied ResultSequence
        /// </summary>
        /// <param name="arg">
        ///            The ResultSequence from which the unsignedByte is to be extracted </param>
        /// <returns> New ResultSequence consisting of the 'unsignedByte' supplied </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 constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            // the function conversion rules apply here too. Get the argument
            // and convert it's string value to a unsignedByte.
            Item aat = arg.first();

            try
            {
                System.Numerics.BigInteger.TryParse(aat.StringValue, out System.Numerics.BigInteger bigInt);

                // doing the range checking
                // min value is 0
                // max value is 255
                System.Numerics.BigInteger min = new System.Numerics.BigInteger(0);
                System.Numerics.BigInteger max = new System.Numerics.BigInteger(255L);

                if (bigInt.CompareTo(min) < 0 || bigInt.CompareTo(max) > 0)
                {
                    // invalid input
                    throw DynamicError.cant_cast(null);
                }

                return(new XSUnsignedByte(bigInt));
            }
            catch (System.FormatException)
            {
                throw DynamicError.cant_cast(null);
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Creates a new ResultSequence consisting of the extractable long in the
        /// supplied ResultSequence
        /// </summary>
        /// <param name="arg">
        ///            The ResultSequence from which the long is to be extracted </param>
        /// <returns> New ResultSequence consisting of the 'long' supplied </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 constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            // the function conversion rules apply here too. Get the argument
            // and convert it's string value to a long.
            Item aat = arg.first();

            try
            {
                System.Numerics.BigInteger.TryParse(aat.StringValue, out System.Numerics.BigInteger bigInt);

                // doing the range checking
                System.Numerics.BigInteger min = new System.Numerics.BigInteger(-9223372036854775808L);
                System.Numerics.BigInteger max = new System.Numerics.BigInteger(9223372036854775807L);

                if (bigInt.CompareTo(min) < 0 || bigInt.CompareTo(max) > 0)
                {
                    // invalid input
                    DynamicError.throw_type_error();
                }

                return(new XSLong(bigInt));
            }
            catch (System.FormatException)
            {
                throw DynamicError.cant_cast(null);
            }
        }
Exemplo n.º 3
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                DynamicError.throw_type_error();
            }
            throw new DynamicError("XPST0080", "Can't Cast to NOTATION");
        }
Exemplo n.º 4
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            AnyAtomicType aat = (AnyAtomicType)arg.first();

            return(new XSUntypedAtomic(aat.StringValue));
        }
Exemplo n.º 5
0
        public static ResultSequence newToOld(org.eclipse.wst.xml.xpath2.api.ResultSequence result)
        {
            if (result is ResultSequence)
            {
                return((ResultSequence)result);
            }

            ResultSequence rs = ResultSequenceFactory.create_new();

            for (int i = 0; i < result.size(); ++i)
            {
                rs.add((AnyType)result.item(i));
            }
            return(rs);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Creation of a result sequence consisting of a URI from a previous result
        /// sequence.
        /// </summary>
        /// <param name="arg">
        ///            previous result sequence </param>
        /// <exception cref="DynamicError"> </exception>
        /// <returns> new result sequence consisting of the URI supplied </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.eclipse.wst.xml.xpath2.api.ResultSequence constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            AnyType aat = (AnyType)arg.first();

            if (!(aat.string_type().Equals("xs:string") || aat.string_type().Equals(XS_ANY_URI) || aat.string_type().Equals("xs:untypedAtomic")))
            {
                throw DynamicError.invalidType();
            }

            return(new XSAnyURI(aat.string_value()));
        }
Exemplo n.º 7
0
        /// <summary>
        /// Creates a new ResultSequence consisting of the ENTITY within
        /// the supplied ResultSequence.  The specification says that this
        /// is relaxed from the XML Schema requirement.  The ENTITY does
        /// not have to be located or expanded during construction and
        /// evaluation for casting.
        /// </summary>
        /// <param name="arg">
        ///            The ResultSequence from which to extract the ENTITY </param>
        /// <returns> New ResultSequence consisting of the ENTITY supplied </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 constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            AnyAtomicType aat      = (AnyAtomicType)arg.first();
            string        strValue = aat.StringValue;

            if (!isConstraintSatisfied(strValue))
            {
                // invalid input
                DynamicError.throw_type_error();
            }

            return(new XSEntity(strValue));
        }
Exemplo n.º 8
0
        /// <summary>
        /// Creates a new ResultSequence consisting of the extractable NMTOKEN within
        /// the supplied ResultSequence
        /// </summary>
        /// <param name="arg">
        ///            The ResultSequence from which to extract the NMTOKEN </param>
        /// <returns> New ResultSequence consisting of the NMTOKEN supplied </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 constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError
        public override ResultSequence constructor(ResultSequence arg)
        {
            if (arg.empty())
            {
                return(ResultBuffer.EMPTY);
            }

            AnyAtomicType aat      = (AnyAtomicType)arg.first();
            string        strValue = aat.StringValue;

            if (!XMLChar.isValidNmtoken(strValue))
            {
                // invalid input
                DynamicError.throw_type_error();
            }

            return(new XSNMTOKEN(strValue));
        }
Exemplo n.º 9
0
 public CollectionAnonymousInnerClass(ResultBuffer outerInstance, org.eclipse.wst.xml.xpath2.api.ResultSequence rs)
 {
     this.outerInstance = outerInstance;
     this.rs            = rs;
 }
Exemplo n.º 10
0
        // convert argument according to section 3.1.5 of xpath 2.0 spec
        /// <summary>
        /// Convert the input argument according to section 3.1.5 of specification.
        /// </summary>
        /// <param name="arg">
        ///            input argument. </param>
        /// <param name="expected">
        ///            Expected Sequence type. </param>
        /// <exception cref="DynamicError">
        ///             Dynamic error. </exception>
        /// <returns> Converted argument. </returns>
        public static org.eclipse.wst.xml.xpath2.api.ResultSequence convert_argument(org.eclipse.wst.xml.xpath2.api.ResultSequence arg, SeqType expected)
        {
            ResultBuffer result = new ResultBuffer();

            // XXX: Should use type_class instead and use item.getClass().isAssignableTo(expected.type_class())
            AnyType expected_type = expected.type();

            // expected is atomic
            if (expected_type is AnyAtomicType)
            {
                AnyAtomicType expected_aat = (AnyAtomicType)expected_type;

                // atomize
                org.eclipse.wst.xml.xpath2.api.ResultSequence rs = FnData.atomize(arg);

                // cast untyped to expected type
                for (var i = rs.iterator(); i.MoveNext();)
                {
                    AnyType item = (AnyType)i.Current;

                    if (item is XSUntypedAtomic)
                    {
                        // create a new item of the expected
                        // type initialized with from the string
                        // value of the item
                        ResultSequence converted = null;
                        if (expected_aat is XSString)
                        {
                            XSString strType = new XSString(item.StringValue);
                            converted = ResultSequenceFactory.create_new(strType);
                        }
                        else
                        {
                            converted = ResultSequenceFactory.create_new(item);
                        }

                        result.concat(converted);
                    }
                    // xs:anyURI promotion to xs:string
                    else if (item is XSAnyURI && expected_aat is XSString)
                    {
                        result.add(new XSString(item.StringValue));
                    }
                    // numeric type promotion
                    else if (item is NumericType)
                    {
                        if (expected_aat is XSDouble)
                        {
                            XSDouble doubleType = new XSDouble(item.StringValue);
                            result.add(doubleType);
                        }
                        else
                        {
                            result.add(item);
                        }
                    }
                    else
                    {
                        result.add(item);
                    }
                }
                // do sequence type matching on converted arguments
                return(expected.match(result.Sequence));
            }
            else
            {
                // do sequence type matching on converted arguments
                return(expected.match(arg));
            }
        }
Exemplo n.º 11
0
        // used for constructor functions
        // arg is either empty sequence, or 1 anyatomictype
        /// <summary>
        /// Used for constructor function.
        /// </summary>
        /// <param name="arg">
        ///            Either an empty sequence or 1 atomic type </param>
        /// <returns> The resulting ResultSequence </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public abstract org.eclipse.wst.xml.xpath2.api.ResultSequence constructor(org.eclipse.wst.xml.xpath2.api.ResultSequence arg) throws org.eclipse.wst.xml.xpath2.processor.DynamicError;
        public abstract ResultSequence constructor(ResultSequence arg);
Exemplo n.º 12
0
        private ResultSequence _rs; // all items in context

        /// <summary>
        /// Sets the _rs to rs and context position to 1.
        /// </summary>
        /// <param name="rs">
        ///            is a ResultSequence and is set to _rs. </param>
        public Focus(ResultSequence rs)
        {
            _rs = rs;
            _cp = 1;
        }