## net.sf.saxon.value
Class IntegerValue

    java.lang.Object
      net.sf.saxon.value.Value
          net.sf.saxon.value.AtomicValue
              net.sf.saxon.value.NumericValue
                  net.sf.saxon.value.IntegerValue

All Implemented Interfaces:
  Serializable, Comparable, PullEvent, SequenceIterable, GroundedValue, Item, ValueRepresentation, ConversionResult

Direct Known Subclasses:
  BigIntegerValue, Int64Value

    public abstract class IntegerValue

extends NumericValue

This class represents the XPath built-in type xs:integer. It is used for all subtypes of xs:integer, other than user-defined subtypes. There are two implementations of IntegerValue: `Int64Value`, which accommodates values up to 2^63, and `BigIntegerValue`, which accommodates unlimited-length integers.

See Also:
  Serialized Form

Field Summary
`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 class net.sf.saxon.value.Value
`INDETERMINATE_ORDERING`

Fields inherited from interface net.sf.saxon.om.ValueRepresentation
`EMPTY_VALUE_ARRAY`

Constructor Summary
`IntegerValue()`

Method Summary
`abstract BigInteger` `asBigInteger()` Get the value as a BigInteger
`static boolean` `checkBigRange(BigInteger big, BuiltInAtomicType type)` Check that a BigInteger is within the required range for a given integer subtype.
`static boolean` `checkRange(long value, BuiltInAtomicType type)` Check that a value is in range for the specified subtype of xs:integer
`abstract ValidationFailure` `convertToSubType(BuiltInAtomicType type, boolean validate)` This class allows subtypes of xs:integer to be held, as well as xs:integer values.
`abstract NumericValue` `div(IntegerValue other)` Divide by another integer
`BuiltInAtomicType` `getPrimitiveType()` Determine the primitive type of the value.
`abstract IntegerValue` `idiv(IntegerValue other)` Integer divide by another integer
`boolean` `isIdentical(Value v)` Determine whether two atomic values are identical, as determined by XML Schema rules.
`boolean` `isWholeNumber()` Determine whether the value is a whole number, that is, whether it compares equal to some integer
`static IntegerValue` `makeIntegerValue(BigInteger value)` Factory method: makes either an Int64Value or a BigIntegerValue depending on the value supplied
`abstract IntegerValue` `minus(IntegerValue other)` Subtract another integer
`abstract IntegerValue` `mod(IntegerValue other)` Take modulo another integer
`abstract IntegerValue` `plus(IntegerValue other)` Add another integer
`protected static int` `signum(int i)` Get the signum of an int
`static ConversionResult` `stringToInteger(CharSequence s)` Static factory method to convert strings to integers.
`abstract IntegerValue` `times(IntegerValue other)` Multiply by another integer
`abstract 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.NumericValue
`abs, ceiling, compareTo, compareTo, equals, floor, getDecimalValue, getDoubleValue, getFloatValue, getXPathComparable, hashCode, isInteger, longValue, negate, parseNumber, round, roundHalfToEven, signum, toString`

Methods inherited from class net.sf.saxon.value.AtomicValue
`asAtomic, checkPermittedContents, convert, convert, convert, convertPrimitive, copyAsSubType, effectiveBooleanValue, getCardinality, getComponent, getItemType, getLength, getPrimitiveStringValue, getSchemaComparable, getStringValue, getStringValueCS, getTypedValue, getTypeLabel, isNaN, itemAt, iterate, process, setTypeLabel, subsequence`

Methods inherited from class net.sf.saxon.value.Value
`asItem, asItem, asIterator, asValue, convertToJava, fromItem, getCanonicalLexicalRepresentation, getIterator, iterate, reduce`

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

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

### IntegerValue

    public IntegerValue()

Method Detail

### makeIntegerValue

    public static IntegerValue makeIntegerValue(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

### convertToSubType

    public abstract ValidationFailure convertToSubType(BuiltInAtomicType type,
                                                       boolean validate)

  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
    `validate` - true if validation is required, false if the caller warrants that the value is valid for the subtype
  Returns:
    null if the operation succeeds, or a ValidationException if the value is out of range

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

### checkBigRange

    public static boolean checkBigRange(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(CharSequence s)

  Static factory method to convert strings to integers.

  Parameters:
    `s` - CharSequence representing 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.

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

### 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 abstract NumericValue div(IntegerValue other)
                              throws XPathException

  Divide by another integer

  Parameters:
    `other` - the other integer
  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

### idiv

    public abstract IntegerValue idiv(IntegerValue other)
                               throws XPathException

  Integer divide by another integer

  Parameters:
    `other` - the other integer
  Returns:
    the result of the integer division
  Throws:
    `XPathException` - if the other integer is zero

### asBigInteger

    public abstract 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(Value 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.

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