## net.sf.saxon.value
Class BigIntegerValue

    java.lang.Object
      |
      +--net.sf.saxon.value.Value
            |
            +--net.sf.saxon.value.AtomicValue
                  |
                  +--net.sf.saxon.value.NumericValue
                        |
                        +--net.sf.saxon.value.BigIntegerValue

All Implemented Interfaces:
  java.lang.Comparable, Expression, Item, java.io.Serializable

public final class BigIntegerValue
extends NumericValue

An integer value: note this is a subtype of decimal in XML Schema, not a primitive type. The class IntegerValue is used to represent xs:integer values that fit comfortably in a Java long; this class is used to represent xs:integer values outside this range, including the built-in subtype xs:unsignedLong

See Also:
  Serialized Form

Field Summary
`static java.math.BigInteger` `ZERO`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`BigIntegerValue(java.math.BigInteger value)`
`BigIntegerValue(long value)`

Method Summary
`NumericValue` `arithmetic(int operator, NumericValue other, XPathContext context)` Evaluate a binary arithmetic operator.
`java.math.BigDecimal` `asDecimal()`
`NumericValue` `ceiling()` Implement the XPath ceiling() function
`int` `compareTo(java.lang.Object other)` Compare the value to another numeric value
`AtomicValue` `convert(int requiredType, XPathContext context)` Convert to target data type
`java.lang.Object` `convertToJava(java.lang.Class target, Configuration config, XPathContext context)` Convert to Java object (for passing to external functions)
`boolean` `effectiveBooleanValue(XPathContext context)` Return the effective boolean value of this integer
`NumericValue` `floor()` Implement the XPath floor() function
`ItemType` `getItemType()` Determine the data type of the expression
`java.lang.String` `getStringValue()` Get the value as a String
`int` `hashCode()` Get the hashCode.
`boolean` `isWholeNumber()` Determine whether the value is a whole number, that is, whether it compares equal to some integer
`boolean` `isWithinLongRange()`
`long` `longValue()` Get the value as a long
`static NumericValue` `makeValue(java.math.BigInteger value)` Factory method: makes either an IntegerValue or a BigIntegerValue depending on the value supplied
`NumericValue` `negate()` Negate the value
`NumericValue` `round()` Implement the XPath round() function
`NumericValue` `roundToHalfEven(int scale)` Implement the XPath round-to-half-even() function

Methods inherited from class net.sf.saxon.value.NumericValue
`equals, getDoubleValue, isInteger, isNaN, parseNumber, promote, toString`

Methods inherited from class net.sf.saxon.value.AtomicValue
`convert, display, evaluateAsString, evaluateItem, getCardinality, getComponent, getImplementationMethod, getPrimitiveValue, getTypedValue, iterate, process`

Methods inherited from class net.sf.saxon.value.Value
`analyze, asItem, asValue, collapseWhitespace, convertJavaObjectToXPath, getDependencies, getParentExpression, getSpecialProperties, inverse, iterateSubExpressions, normalizeWhitespace, promote, simplify, stringToNumber, trimWhitespace`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### ZERO

    public static final java.math.BigInteger ZERO

Constructor Detail

### BigIntegerValue

    public BigIntegerValue(java.math.BigInteger value)

### BigIntegerValue

    public BigIntegerValue(long value)

Method Detail

### makeValue

    public static NumericValue makeValue(java.math.BigInteger value)

  Factory method: makes either an IntegerValue or a BigIntegerValue depending on the value supplied

### 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 as a long

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

### isWithinLongRange

    public boolean isWithinLongRange()

### asDecimal

    public java.math.BigDecimal asDecimal()

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)

  Return the effective boolean value of this integer

  Specified by:
    `effectiveBooleanValue` in interface `Expression`
  Overrides:
    `effectiveBooleanValue` in class `AtomicValue`
  Parameters:
    `context` - The dynamic evaluation context; ignored in this implementation of the method
  Returns:
    false if the integer is zero, otherwise true

### compareTo

    public int compareTo(java.lang.Object other)

  Compare the value to another numeric value

  Specified by:
    `compareTo` in interface `java.lang.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

### convert

    public AtomicValue convert(int requiredType,
                               XPathContext context)
                        throws XPathException

  Convert to target data type

  Specified by:
    `convert` in class `AtomicValue`
  Parameters:
    `requiredType` - an integer identifying the required atomic type
    `context` - the evaluation context. Used primarily for error reporting, since nearly all type conversions are context-independent. The value may be null if the context is not known.
  Returns:
    an AtomicValue, a value of the required type
  Throws:
    `XPathException` - if the conversion is not possible

### getStringValue

    public java.lang.String getStringValue()

  Get the value as a String

  Specified by:
    `getStringValue` in interface `Item`
  Specified by:
    `getStringValue` in class `AtomicValue`
  Returns:
    a String representation of the 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()

  Implement the XPath round() function

  Specified by:
    `round` in class `NumericValue`
  Returns:
    the integer value, unchanged

### roundToHalfEven

    public NumericValue roundToHalfEven(int scale)

  Implement the XPath round-to-half-even() function

  Specified by:
    `roundToHalfEven` 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

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

### arithmetic

    public NumericValue arithmetic(int operator,
                                   NumericValue other,
                                   XPathContext context)
                            throws XPathException

  Evaluate a binary arithmetic operator.

  Specified by:
    `arithmetic` in class `NumericValue`
  Parameters:
    `operator` - the operator to be applied, identified by a constant in the Tokenizer class
    `other` - the other operand of the arithmetic expression
  Returns:
    the result of performing the arithmetic operation
  Throws:
    `XPathException` - if an arithmetic failure occurs, e.g. divide by zero
  See Also:
    `Tokenizer`

### getItemType

    public ItemType getItemType()

  Determine the data type of the expression

  Returns:
    the actual data type

### convertToJava

    public java.lang.Object convertToJava(java.lang.Class target,
                                          Configuration config,
                                          XPathContext context)
                                   throws XPathException

  Convert to Java object (for passing to external functions)

  Overrides:
    `convertToJava` in class `AtomicValue`
  Parameters:
    `target` - The Java class to which conversion is required
    `config` - The configuration (needed for access to schema information)
  Returns:
    the Java object that results from the conversion; always an instance of the target class
  Throws:
    `XPathException` - if conversion is not possible, or fails