net.sf.saxon.value

## Class Int64Value

- java.lang.Object
- - net.sf.saxon.om.AbstractItem
  - - net.sf.saxon.value.AtomicValue
    - - net.sf.saxon.value.NumericValue
      - - net.sf.saxon.value.IntegerValue
        - - net.sf.saxon.value.Int64Value

- All Implemented Interfaces:
    Comparable, PullEvent, AtomicSequence, GroundedValue, IdentityComparable, Item, Sequence, ConversionResult

      public final class Int64Value
      extends IntegerValue

  An integer value: note this is a subtype of decimal in XML Schema, not a primitive type. This class supports integer values in the range permitted by a Java "long", and also supports the built-in subtypes of xs:integer.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `Int64Value.Int64Comparable` A Comparable that performs comparison of an Int64Value either with another Int64Value or with some other representation of an XPath numeric value

  - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.value.IntegerValue

      `MAX_LONG, MIN_LONG, MINUS_ONE, PLUS_ONE, ZERO`

    - ### Fields inherited from class net.sf.saxon.value.AtomicValue

      `typeLabel`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Int64Value(long value)` Constructor supplying a long
    `Int64Value(long val, BuiltInAtomicType type, boolean check)` Constructor for a subtype, supplying a long and a type label.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `NumericValue` | `abs()` Get the absolute value as defined by the XPath abs() function
    `BigInteger` | `asBigInteger()` Get the value as a BigInteger
    `NumericValue` | `ceiling()` Implement the XPath ceiling() function
    `boolean` | `checkRange(BuiltInAtomicType type)` This class allows subtypes of xs:integer to be held, as well as xs:integer values.
    `int` | `compareTo(long other)` Compare the value to a long
    `int` | `compareTo(Object other)` Compare the value to another numeric value
    `ValidationFailure` | `convertToSubType(BuiltInAtomicType subtype, boolean validate)` Convert the value to a subtype of xs:integer
    `AtomicValue` | `copyAsSubType(AtomicType typeLabel)` Create a copy of this atomic value, with a different type label
    `NumericValue` | `div(IntegerValue other)` Divide by another integer
    `boolean` | `effectiveBooleanValue()` Return the effective boolean value of this integer
    `NumericValue` | `floor()` Implement the XPath floor() function
    `BigDecimal` | `getDecimalValue()` Get the numeric value converted to a decimal
    `double` | `getDoubleValue()` Get the numeric value as a double
    `float` | `getFloatValue()` Get the numeric value converted to a float
    `String` | `getPrimitiveStringValue()` Get the value as a String
    `Comparable` | `getSchemaComparable()` Get an object that implements XML Schema comparison semantics
    `int` | `hashCode()` Get the hashCode.
    `IntegerValue` | `idiv(IntegerValue other)` Integer divide by another integer
    `long` | `longValue()` Get the value
    `static Int64Value` | `makeDerived(long val, AtomicType type)` Factory method to create a derived value, with no checking of the value against the derived type
    `static Int64Value` | `makeIntegerValue(long value)` Factory method: allows Int64Value objects to be reused.
    `IntegerValue` | `minus(IntegerValue other)` Subtract another integer
    `IntegerValue` | `mod(IntegerValue other)` Take modulo another integer
    `NumericValue` | `negate()` Negate the value
    `IntegerValue` | `plus(IntegerValue other)` Add another integer
    `NumericValue` | `round(int scale)` Implement the XPath round() function
    `NumericValue` | `roundHalfToEven(int scale)` Implement the XPath round-to-half-even() function
    `void` | `setSubType(AtomicType type)` This class allows subtypes of xs:integer to be held, as well as xs:integer values.
    `int` | `signum()` Determine whether the value is negative, zero, or positive
    `static Int64Value` | `signum(long val)` Factory method returning the integer -1, 0, or +1 according as the argument is negative, zero, or positive
    `IntegerValue` | `times(IntegerValue other)` Multiply by another integer
    `ValidationFailure` | `validateAgainstSubType(BuiltInAtomicType type)` This class allows subtypes of xs:integer to be held, as well as xs:integer values.

    - ### Methods inherited from class net.sf.saxon.value.IntegerValue

      `castableAsInteger, checkBigRange, checkRange, getMaxInclusive, getMinInclusive, getPrimitiveType, isIdentical, isWholeNumber, makeIntegerValue, makeIntegerValue, makeIntegerValue, signum, stringToInteger`

    - ### Methods inherited from class net.sf.saxon.value.NumericValue

      `equals, getXPathComparable, isInteger, parseNumber, toString`

    - ### Methods inherited from class net.sf.saxon.value.AtomicValue

      `asAtomic, checkPermittedContents, getCanonicalLexicalRepresentation, getCardinality, getComponent, getItemType, getStringValue, getStringValueCS, head, isIdentical, isNaN, itemAt, iterate, process, setTypeLabel`

    - ### Methods inherited from class net.sf.saxon.om.AbstractItem

      `getLength, reduce, subsequence`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.om.AtomicSequence

      `getLength`

    - ### Methods inherited from interface net.sf.saxon.om.GroundedValue

      `reduce, subsequence`

- - ### Constructor Detail

    - #### Int64Value

          public Int64Value(long value)

      Constructor supplying a long
      Parameters:
        `value` - the value of the IntegerValue

    - #### Int64Value

          public Int64Value(long val,
                    BuiltInAtomicType type,
                    boolean check)
                     throws XPathException

      Constructor for a subtype, supplying a long and a type label.
      Parameters:
        `val` - The supplied value, as an integer
        `type` - the required item type, a subtype of xs:integer
        `check` - Set to true if the method is required to check that the value is in range; false if the caller can guarantee that the value has already been checked.
      Throws:
        `XPathException` - if the supplied value is out of range for the target type

  - ### Method Detail

    - #### makeIntegerValue

          public static Int64Value makeIntegerValue(long value)

      Factory method: allows Int64Value objects to be reused. Note that a value obtained using this method must not be modified to set a type label, because the value is in general shared.
      Parameters:
        `value` - the integer value
      Returns:
        an Int64Value with this integer value

    - #### makeDerived

          public static Int64Value makeDerived(long val,
                               AtomicType type)

      Factory method to create a derived value, with no checking of the value against the derived type
      Parameters:
        `val` - the integer value
        `type` - the subtype of xs:integer
      Returns:
        the constructed value

    - #### signum

          public static Int64Value signum(long val)

      Factory method returning the integer -1, 0, or +1 according as the argument is negative, zero, or positive
      Parameters:
        `val` - the value to be tested
      Returns:
        the Int64Value representing -1, 0, or +1

    - #### copyAsSubType

          public AtomicValue copyAsSubType(AtomicType typeLabel)

      Create a copy of this atomic value, with a different type label
      Specified by:
        `copyAsSubType` in class `AtomicValue`
      Parameters:
        `typeLabel` - the type label of the new copy. The caller is responsible for checking that the value actually conforms to this type.
      Returns:
        the copied value

    - #### convertToSubType

          public ValidationFailure convertToSubType(BuiltInAtomicType subtype,
                                           boolean validate)

      Convert the value to a subtype of xs:integer
      Specified by:
        `convertToSubType` in class `IntegerValue`
      Parameters:
        `subtype` - the target subtype
        `validate` - true if validation is required; false if the caller already knows that the value is valid
      Returns:
        null if the conversion succeeds; a ValidationFailure describing the failure if it fails. Note that the exception is returned, not thrown.

    - #### validateAgainstSubType

          public 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.
      Specified by:
        `validateAgainstSubType` in class `IntegerValue`
      Parameters:
        `type` - the subtype of integer required
      Returns:
        null if the operation succeeds, or a ValidationException if the value is out of range

    - #### setSubType

          public void setSubType(AtomicType type)

      This class allows subtypes of xs:integer to be held, as well as xs:integer values. This method sets the required type label. It is the caller's responsibility to check that the value is within range.
      Parameters:
        `type` - the type label to be assigned

    - #### checkRange

          public boolean checkRange(BuiltInAtomicType type)

      This class allows subtypes of xs:integer to be held, as well as xs:integer values. This method checks that the value is within range, and also sets the type label.
      Parameters:
        `type` - the subtype of integer required
      Returns:
        true if successful, false if value is out of range for the subtype

    - #### getSchemaComparable

          public Comparable getSchemaComparable()

      Get an object that implements XML Schema comparison semantics
      Specified by:
        `getSchemaComparable` in interface `AtomicSequence`
      Specified by:
        `getSchemaComparable` in class `AtomicValue`
      Returns:
        a Comparable that follows XML Schema comparison rules

    - #### hashCode

          public int hashCode()

      Get the hashCode. This must conform to the rules for other NumericValue hashcodes
      Specified by:
        `hashCode` in class `NumericValue`
      Returns:
        the hash code of the numeric value
      See Also:
        `NumericValue.hashCode()`

    - #### longValue

          public long longValue()

      Get the value
      Specified by:
        `longValue` in class `NumericValue`
      Returns:
        the value of the xs:integer, as a Java long

    - #### effectiveBooleanValue

          public boolean effectiveBooleanValue()

      Return the effective boolean value of this integer
      Specified by:
        `effectiveBooleanValue` in interface `GroundedValue`
      Overrides:
        `effectiveBooleanValue` in class `AtomicValue`
      Returns:
        false if the integer is zero, otherwise true

    - #### compareTo

          public int compareTo(Object other)

      Compare the value to another numeric value
      Specified by:
        `compareTo` in interface `Comparable`
      Overrides:
        `compareTo` in class `NumericValue`
      Parameters:
        `other` - the numeric value to be compared to this value
      Returns:
        -1 if this value is less than the other, 0 if they are equal, +1 if this value is greater

    - #### compareTo

          public int compareTo(long other)

      Compare the value to a long
      Specified by:
        `compareTo` in class `NumericValue`
      Parameters:
        `other` - the value to be compared with
      Returns:
        -1 if this is less, 0 if this is equal, +1 if this is greater or if this is NaN

    - #### getPrimitiveStringValue

          public String getPrimitiveStringValue()

      Get the value as a String
      Specified by:
        `getPrimitiveStringValue` in class `AtomicValue`
      Returns:
        a String representation of the value

    - #### getDoubleValue

          public double getDoubleValue()

      Get the numeric value as a double
      Specified by:
        `getDoubleValue` in class `NumericValue`
      Returns:
        A double representing this numeric value; NaN if it cannot be converted

    - #### getFloatValue

          public float getFloatValue()

      Get the numeric value converted to a float
      Specified by:
        `getFloatValue` in class `NumericValue`
      Returns:
        a float representing this numeric value; NaN if it cannot be converted

    - #### getDecimalValue

          public BigDecimal getDecimalValue()

      Get the numeric value converted to a decimal
      Specified by:
        `getDecimalValue` in class `NumericValue`
      Returns:
        a decimal representing this numeric value;

    - #### negate

          public NumericValue negate()

      Negate the value
      Specified by:
        `negate` in class `NumericValue`
      Returns:
        the result of inverting the sign of the value

    - #### floor

          public NumericValue floor()

      Implement the XPath floor() function
      Specified by:
        `floor` in class `NumericValue`
      Returns:
        the integer value, unchanged

    - #### ceiling

          public NumericValue ceiling()

      Implement the XPath ceiling() function
      Specified by:
        `ceiling` in class `NumericValue`
      Returns:
        the integer value, unchanged

    - #### round

          public NumericValue round(int scale)

      Implement the XPath round() function
      Specified by:
        `round` in class `NumericValue`
      Parameters:
        `scale` - the scale (for example scale=2 rounds to 2 decimal places, scale=-2 rounds to a multiple of 100); default value is zero which rounds to an integer
      Returns:
        the integer value, unchanged

    - #### roundHalfToEven

          public NumericValue roundHalfToEven(int scale)

      Implement the XPath round-to-half-even() function
      Specified by:
        `roundHalfToEven` in class `NumericValue`
      Parameters:
        `scale` - number of digits required after the decimal point; the value -2 (for example) means round to a multiple of 100
      Returns:
        if the scale is >=0, return this value unchanged. Otherwise round it to a multiple of 10**-scale

    - #### signum

          public int signum()

      Determine whether the value is negative, zero, or positive
      Specified by:
        `signum` in class `NumericValue`
      Returns:
        -1 if negative, 0 if zero, +1 if positive, NaN if NaN

    - #### abs

          public NumericValue abs()

      Get the absolute value as defined by the XPath abs() function
      Specified by:
        `abs` in class `NumericValue`
      Returns:
        the absolute value

    - #### plus

          public IntegerValue plus(IntegerValue other)

      Add another integer
      Specified by:
        `plus` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the addition

    - #### minus

          public IntegerValue minus(IntegerValue other)

      Subtract another integer
      Specified by:
        `minus` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the subtraction

    - #### times

          public IntegerValue times(IntegerValue other)

      Multiply by another integer
      Specified by:
        `times` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the multiplication

    - #### div

          public NumericValue div(IntegerValue other)
                           throws XPathException

      Divide by another integer
      Specified by:
        `div` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the division
      Throws:
        `XPathException` - if the other integer is zero

    - #### mod

          public IntegerValue mod(IntegerValue other)
                           throws XPathException

      Take modulo another integer
      Specified by:
        `mod` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the modulo operation (the remainder)
      Throws:
        `XPathException` - if the other integer is zero

    - #### idiv

          public IntegerValue idiv(IntegerValue other)
                            throws XPathException

      Integer divide by another integer
      Specified by:
        `idiv` in class `IntegerValue`
      Parameters:
        `other` - the other integer
      Returns:
        the result of the integer division
      Throws:
        `XPathException` - if the other integer is zero

    - #### asBigInteger

          public BigInteger asBigInteger()

      Get the value as a BigInteger
      Specified by:
        `asBigInteger` in class `IntegerValue`
      Returns:
        the value, as a BigInteger

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.