Package net.sf.saxon.value

Class IntegerValue

    • Constructor Detail

      • IntegerValue

        public IntegerValue​(AtomicType typeLabel)

    • Method Detail

      • makeIntegerValue

        public static IntegerValue makeIntegerValue​(java.math.BigInteger value)
        Factory method: makes either an Int64Value or a BigIntegerValue depending on the value supplied
        Parameters:
        value - the supplied integer value
        Returns:
        the value as a BigIntegerValue or Int64Value as appropriate

      • fromDouble

        public static ConversionResult fromDouble​(double value)
        Convert a double to an integer
        Parameters:
        value - the double to be converted
        Returns:
        the result of the conversion, or the validation failure if the input is NaN or infinity

      • validateAgainstSubType

        public abstract ValidationFailure validateAgainstSubType​(BuiltInAtomicType type)
        This class allows subtypes of xs:integer to be held, as well as xs:integer values. This method sets the required type label. Note that this method modifies the value in situ.
        Parameters:
        type - the subtype of integer required
        Returns:
        null if the operation succeeds, or a ValidationException if the value is out of range

      • checkRange

        public static boolean checkRange​(long value,
                                 BuiltInAtomicType type)
        Check that a value is in range for the specified subtype of xs:integer
        Parameters:
        value - the value to be checked
        type - the required item type, a subtype of xs:integer
        Returns:
        true if successful, false if value is out of range for the subtype

      • getMinInclusive

        public static IntegerValue getMinInclusive​(BuiltInAtomicType type)
        Get the minInclusive facet for a built-in integer subtype
        Parameters:
        type - the built-in type, which must be derived from xs:integer
        Returns:
        the value of the minInclusive facet if there is a lower limit, or null if not

      • getMaxInclusive

        public static IntegerValue getMaxInclusive​(BuiltInAtomicType type)
        Get the maxInclusive facet for a built-in integer subtype
        Parameters:
        type - the built-in type, which must be derived from xs:integer
        Returns:
        the value of the minInclusive facet if there is a lower limit, or null if not

      • checkBigRange

        public static boolean checkBigRange​(java.math.BigInteger big,
                                    BuiltInAtomicType type)
        Check that a BigInteger is within the required range for a given integer subtype. This method is expensive, so it should not be used unless the BigInteger is outside the range of a long.
        Parameters:
        big - the supplied BigInteger
        type - the derived type (a built-in restriction of xs:integer) to check the value against
        Returns:
        true if the value is within the range for the derived type

      • stringToInteger

        public static ConversionResult stringToInteger​(java.lang.String s)
        Static factory method to convert strings to integers.
        Parameters:
        s - the string to be converted
        Returns:
        either an Int64Value or a BigIntegerValue representing the value of the String, or a ValidationFailure encapsulating an Exception if the value cannot be converted.

      • castableAsInteger

        public static ValidationFailure castableAsInteger​(UnicodeString input)
        Determine whether a string is castable as an integer
        Parameters:
        input - the string to be tested
        Returns:
        null if the string is castable to an integer, or a validation failure otherwise

      • getPrimitiveType

        public BuiltInAtomicType getPrimitiveType()
        Determine the primitive type of the value. This delivers the same answer as getItemType().getPrimitiveItemType(). The primitive types are the 19 primitive types of XML Schema, plus xs:integer, xs:dayTimeDuration and xs:yearMonthDuration, and xs:untypedAtomic. For external objects, the result is AnyAtomicType.
        Specified by:
        getPrimitiveType in class AtomicValue
        Returns:
        the primitive type

      • getDecimalValue

        public abstract java.math.BigDecimal getDecimalValue()
        Get the numeric value converted to a decimal
        Specified by:
        getDecimalValue in class DecimalValue
        Returns:
        a decimal representing this numeric value;

      • isWholeNumber

        public boolean isWholeNumber()
        Determine whether the value is a whole number, that is, whether it compares equal to some integer
        Specified by:
        isWholeNumber in class NumericValue
        Returns:
        always true for this implementation

      • plus

        public abstract IntegerValue plus​(IntegerValue other)
        Add another integer
        Parameters:
        other - the other integer
        Returns:
        the result of the addition

      • minus

        public abstract IntegerValue minus​(IntegerValue other)
        Subtract another integer
        Parameters:
        other - the other integer
        Returns:
        the result of the subtraction

      • times

        public abstract IntegerValue times​(IntegerValue other)
        Multiply by another integer
        Parameters:
        other - the other integer
        Returns:
        the result of the multiplication

      • div

        public NumericValue div​(IntegerValue other,
                        Location locator)
                 throws XPathException
        Divide by another integer, providing location information for any exception
        Parameters:
        other - the other integer
        locator - the location of the expression, for use in diagnostics
        Returns:
        the result of the division
        Throws:
        XPathException - if the other integer is zero

      • mod

        public abstract IntegerValue mod​(IntegerValue other)
                          throws XPathException
        Take modulo another integer
        Parameters:
        other - the other integer
        Returns:
        the result of the modulo operation (the remainder)
        Throws:
        XPathException - if the other integer is zero

      • mod

        public IntegerValue mod​(IntegerValue other,
                        Location locator)
                 throws XPathException
        Take modulo another integer, providing location information for any exception
        Parameters:
        other - the other integer
        locator - the location of the expression, for use in diagnostics
        Returns:
        the result of the division
        Throws:
        XPathException - if the other integer is zero

      • idiv

        public IntegerValue idiv​(IntegerValue other,
                         Location locator)
                  throws XPathException
        Integer divide by another integer, providing location information for any exception
        Parameters:
        other - the other integer
        locator - the location of the expression, for use in diagnostics
        Returns:
        the result of the division
        Throws:
        XPathException - if the other integer is zero

      • asBigInteger

        public abstract java.math.BigInteger asBigInteger()
        Get the value as a BigInteger
        Returns:
        the value, as a BigInteger

      • signum

        protected static int signum​(int i)
        Get the signum of an int
        Parameters:
        i - the int
        Returns:
        -1 if the integer is negative, 0 if it is zero, +1 if it is positive

      • isIdentical

        public boolean isIdentical​(AtomicValue v)
        Determine whether two atomic values are identical, as determined by XML Schema rules. This is a stronger test than equality (even schema-equality); for example two dateTime values are not identical unless they are in the same timezone.

        Note that even this check ignores the type annotation of the value. The integer 3 and the short 3 are considered identical, even though they are not fully interchangeable. "Identical" means the same point in the value space, regardless of type annotation.

        NaN is identical to itself.

        Overrides:
        isIdentical in class AtomicValue
        Parameters:
        v - the other value to be compared with this one
        Returns:
        true if the two values are identical, false otherwise.