Package net.sf.saxon.value

## Class Int64Value

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

- All Implemented Interfaces:
    `java.lang.Comparable<NumericValue>`, `java.lang.Iterable<AtomicValue>`, `AtomicMatchKey`, `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 | 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
    Modifier and Type | Field | Description
    --- | --- | ---
    `static Int64Value` | `MAX_LONG` | IntegerValue representing the maximum value for a long
    `static Int64Value` | `MIN_LONG` | IntegerValue representing the minimum value for a long
    `static Int64Value` | `MINUS_ONE` | IntegerValue representing the value -1
    `static Int64Value` | `PLUS_ONE` | IntegerValue representing the value +1
    `static Int64Value` | `ZERO` | IntegerValue representing the value zero

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

      `typeLabel`

    - ### Fields inherited from interface net.sf.saxon.expr.sort.AtomicMatchKey

      `NaN_MATCH_KEY`

  - ### Constructor Summary

    Constructors
    Constructor | 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

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `NumericValue` | `abs()` | Get the absolute value as defined by the XPath abs() function
    `java.math.BigInteger` | `asBigInteger()` | Get the value as a BigInteger
    `int` | `asSubscript()` | Test whether a number is a possible subscript into a sequence, that is, a whole number greater than zero and less than 2^31
    `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​(NumericValue 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
    `java.math.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
    `java.lang.String` | `getPrimitiveStringValue()` | Get the value as a String
    `java.lang.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, div, getMaxInclusive, getMinInclusive, getPrimitiveType, idiv, isIdentical, isWholeNumber, makeIntegerValue, makeIntegerValue, makeIntegerValue, mod, signum, stringToInteger`

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

      `equals, getXPathComparable, isInteger, isNegativeZero, parseNumber, toString`

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

      `asAtomic, asMapKey, atomize, checkPermittedContents, checkValidInJavascript, getCanonicalLexicalRepresentation, getCardinality, getComponent, getGenre, getItemType, getLength, getStringValue, getStringValueCS, getUType, head, identityHashCode, isIdentical, isNaN, itemAt, iterate, iterator, setTypeLabel`

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

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

    - ### Methods inherited from interface net.sf.saxon.expr.sort.AtomicMatchKey

      `asAtomic`

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

      `asIterable, concatenate, containsNode, materialize`

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

      `isStreamed, reduce, subsequence, toShortString`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach, spliterator`

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

      `makeRepeatable`

- - ### Field Detail

    - #### MINUS_ONE

          public static final Int64Value MINUS_ONE

      IntegerValue representing the value -1

    - #### ZERO

          public static final Int64Value ZERO

      IntegerValue representing the value zero

    - #### PLUS_ONE

          public static final Int64Value PLUS_ONE

      IntegerValue representing the value +1

    - #### MAX_LONG

          public static final Int64Value MAX_LONG

      IntegerValue representing the maximum value for a long

    - #### MIN_LONG

          public static final Int64Value MIN_LONG

      IntegerValue representing the minimum value for a long

  - ### 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

    - #### asSubscript

          public int asSubscript()

      Test whether a number is a possible subscript into a sequence, that is, a whole number greater than zero and less than 2^31
      Specified by:
        `asSubscript` in class `NumericValue`
      Returns:
        the number as an int if it is a possible subscript, or -1 otherwise

    - #### 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 java.lang.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`
      Specified by:
        `effectiveBooleanValue` in class `NumericValue`
      Returns:
        false if the integer is zero, otherwise true

    - #### compareTo

          public int compareTo​(NumericValue other)

      Compare the value to another numeric value
      Specified by:
        `compareTo` in interface `java.lang.Comparable<NumericValue>`
      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 java.lang.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 java.math.BigDecimal getDecimalValue()

      Get the numeric value converted to a decimal
      Specified by:
        `getDecimalValue` in class `IntegerValue`
      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 java.math.BigInteger asBigInteger()

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