com.sun.jna

## Class IntegerType

- java.lang.Object
- - java.lang.Number
  - - com.sun.jna.IntegerType

All Implemented Interfaces:
  NativeMapped, java.io.Serializable

Direct Known Subclasses:
  BaseTSD.DWORD_PTR, BaseTSD.LONG_PTR, BaseTSD.ULONG_PTR, LibCAPI.size_t, LibCAPI.ssize_t, NativeLong, OaIdl.VARIANT_BOOL, Structure.FFIType.size_t, WinDef.BOOL, WinDef.CHAR, WinDef.DWORD, WinDef.DWORDLONG, WinDef.INT_PTR, WinDef.LONG, WinDef.LONGLONG, WinDef.SHORT, WinDef.UCHAR, WinDef.UINT, WinDef.UINT_PTR, WinDef.ULONG, WinDef.ULONGLONG, WinDef.USHORT, WinDef.WORD, XAttr.size_t, XAttr.ssize_t

    public abstract class IntegerType
    extends java.lang.Number
    implements NativeMapped

Represents a native integer value, which may have a platform-specific size (e.g. `long` on unix-based platforms). May optionally indicate an unsigned attribute, such that when a value is extracted into a larger-sized container (e.g. `int` retrieved via `Number.longValue()`, the value will be unsigned. Default behavior is signed.

Author:
  wmeissner@gmail.com, twalljava@java.net
See Also:
  Serialized Form

### Constructor Summary

Constructors
Constructor and Description
`IntegerType(int size)` Create a zero-valued signed IntegerType.
`IntegerType(int size, boolean unsigned)` Create a zero-valued optionally unsigned IntegerType.
`IntegerType(int size, long value)` Create a signed IntegerType with the given value.
`IntegerType(int size, long value, boolean unsigned)` Create an optionally signed IntegerType with the given value.

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`static int` `compare(IntegerType v1, long v2)` Compares a IntegerType value with a `long` one.
`static int` `compare(long v1, long v2)`
`static <T extends IntegerType> int` `compare(T v1, T v2)` Compares 2 derived `IntegerType` values - Note: a `null` value is considered greater than any non-`null` one (i.e., `null` values are "pushed" to the end of a sorted array / list of values)
`double` `doubleValue()`
`boolean` `equals(java.lang.Object rhs)`
`float` `floatValue()`
`java.lang.Object` `fromNative(java.lang.Object nativeValue, FromNativeContext context)` Convert the given native object into its Java representation using the given context.
`int` `hashCode()`
`int` `intValue()`
`long` `longValue()`
`java.lang.Class<?>` `nativeType()` Indicate the native type used by this converter.
`void` `setValue(long value)` Change the value for this data.
`java.lang.Object` `toNative()` Convert this object into a supported native type.
`java.lang.String` `toString()`

### Methods inherited from class java.lang.Number

`byteValue, shortValue`

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

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

### Constructor Detail

#### IntegerType

    public IntegerType(int size)

Create a zero-valued signed IntegerType.

#### IntegerType

    public IntegerType(int size,
                       boolean unsigned)

Create a zero-valued optionally unsigned IntegerType.

#### IntegerType

    public IntegerType(int size,
                       long value)

Create a signed IntegerType with the given value.

#### IntegerType

    public IntegerType(int size,
                       long value,
                       boolean unsigned)

Create an optionally signed IntegerType with the given value.

### Method Detail

#### setValue

    public void setValue(long value)

Change the value for this data.

Parameters:
  `value` - value to set

#### toNative

    public java.lang.Object toNative()

Description copied from interface: `NativeMapped`
Convert this object into a supported native type.

Specified by:
  `toNative` in interface `NativeMapped`
Returns:
  Java representation of the original Java object converted to a native type.

#### fromNative

    public java.lang.Object fromNative(java.lang.Object nativeValue,
                                       FromNativeContext context)

Description copied from interface: `NativeMapped`
Convert the given native object into its Java representation using the given context.

Specified by:
  `fromNative` in interface `NativeMapped`
Parameters:
  `nativeValue` - Java representation of the native type to be converted.
  `context` - Context in which the conversion is taking place.
Returns:
  Converted object.

#### nativeType

    public java.lang.Class<?> nativeType()

Description copied from interface: `NativeMapped`
Indicate the native type used by this converter.

Specified by:
  `nativeType` in interface `NativeMapped`
Returns:
  Java class representation of the native type.

#### intValue

    public int intValue()

Specified by:
  `intValue` in class `java.lang.Number`

#### longValue

    public long longValue()

Specified by:
  `longValue` in class `java.lang.Number`

#### floatValue

    public float floatValue()

Specified by:
  `floatValue` in class `java.lang.Number`

#### doubleValue

    public double doubleValue()

Specified by:
  `doubleValue` in class `java.lang.Number`

#### equals

    public boolean equals(java.lang.Object rhs)

Overrides:
  `equals` in class `java.lang.Object`

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `java.lang.Object`

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `java.lang.Object`

#### compare

    public static <T extends IntegerType> int compare(T v1,
                                                      T v2)

Compares 2 derived `IntegerType` values - Note: a `null` value is considered greater than any non-`null` one (i.e., `null` values are "pushed" to the end of a sorted array / list of values)

Type Parameters:
  `T` - the derived integer type
Parameters:
  `v1` - The 1st value
  `v2` - The 2nd value
Returns:
  0 if values are equal - including if both are `null`, negative if 1st value less than 2nd one, positive otherwise. Note: the comparison uses the `longValue()`.
See Also:
  `compare(long, long)`

#### compare

    public static int compare(IntegerType v1,
                              long v2)

Compares a IntegerType value with a `long` one. Note: if the IntegerType value is `null` then it is consider greater than any `long` value.

Parameters:
  `v1` - The `IntegerType` value
  `v2` - The `long` value
Returns:
  0 if values are equal, negative if 1st value less than 2nd one, positive otherwise. Note: the comparison uses the `longValue()`.
See Also:
  `compare(long, long)`

#### compare

    public static final int compare(long v1,
                                    long v2)

Copyright © 2007-2018 Timothy Wall. All Rights Reserved.