Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.value
Class Int64Value

    java.lang.Object
      net.sf.saxon.value.Value<AtomicValue>
          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, GroundedValue<AtomicValue>, Item<AtomicValue>, ValueRepresentation<AtomicValue>, 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
`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`

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
`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
`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, 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, getCardinality, getComponent, getItemType, getLength, 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, getSequenceLength, reduce`

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

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

  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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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