WinNT.LARGE_INTEGER (JNA API)

com.sun.jna.platform.win32

## Class WinNT.LARGE_INTEGER

- java.lang.Object
- - com.sun.jna.Structure
  - - com.sun.jna.platform.win32.WinNT.LARGE_INTEGER

- All Implemented Interfaces:
    java.lang.Comparable<WinNT.LARGE_INTEGER>
  Direct Known Subclasses:
    WinNT.LARGE_INTEGER.ByReference
  Enclosing interface:
    WinNT

      public static class WinNT.LARGE_INTEGER
      extends Structure
      implements java.lang.Comparable<WinNT.LARGE_INTEGER>

  A 64-bit integer;

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `WinNT.LARGE_INTEGER.ByReference`
    `static class` | `WinNT.LARGE_INTEGER.LowHigh`
    `static class` | `WinNT.LARGE_INTEGER.UNION`

    - ### Nested classes/interfaces inherited from class com.sun.jna.Structure

      `Structure.ByValue, Structure.StructField`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `WinNT.LARGE_INTEGER.UNION` | `u`

    - ### Fields inherited from class com.sun.jna.Structure

      `ALIGN_DEFAULT, ALIGN_GNUC, ALIGN_MSVC, ALIGN_NONE, CALCULATE_SIZE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `WinNT.LARGE_INTEGER()`
    `WinNT.LARGE_INTEGER(long value)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static int` | `compare(WinNT.LARGE_INTEGER v1, long v2)` Compares a LARGE_INTEGER value with a `long` one.
    `static int` | `compare(WinNT.LARGE_INTEGER v1, WinNT.LARGE_INTEGER v2)` Compares 2 LARGE_INTEGER 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)
    `int` | `compareTo(WinNT.LARGE_INTEGER other)`
    `protected java.util.List<java.lang.String>` | `getFieldOrder()` Return this Structure's field names in their proper order.
    `WinDef.DWORD` | `getHigh()` High DWORD.
    `WinDef.DWORD` | `getLow()` Low DWORD.
    `long` | `getValue()` 64-bit value.
    `java.lang.String` | `toString()` If `jna.dump_memory` is true, will include a native memory dump of the Structure's backing memory.

    - ### Methods inherited from class com.sun.jna.Structure

      `allocateMemory, allocateMemory, autoAllocate, autoRead, autoRead, autoWrite, autoWrite, cacheTypeInfo, calculateSize, clear, createFieldsOrder, createFieldsOrder, createFieldsOrder, createFieldsOrder, dataEquals, dataEquals, ensureAllocated, equals, fieldOffset, getAutoRead, getAutoWrite, getFieldList, getFields, getNativeAlignment, getNativeSize, getNativeSize, getPointer, getStringEncoding, getStructAlignment, hashCode, newInstance, newInstance, read, readField, readField, setAlignType, setAutoRead, setAutoSynch, setAutoWrite, setFieldOrder, setStringEncoding, size, sortFields, toArray, toArray, toString, useMemory, useMemory, write, writeField, writeField, writeField`

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

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

- - ### Field Detail

    - #### u

          public WinNT.LARGE_INTEGER.UNION u

  - ### Constructor Detail

    - #### WinNT.LARGE_INTEGER

          public WinNT.LARGE_INTEGER()

    - #### WinNT.LARGE_INTEGER

          public WinNT.LARGE_INTEGER(long value)

  - ### Method Detail

    - #### getFieldOrder

          protected java.util.List<java.lang.String> getFieldOrder()

      Description copied from class: `Structure`
      Return this Structure's field names in their proper order. For example,

           protected List getFieldOrder() {
               return Arrays.asList(new String[] { ... });
           }

      IMPORTANT When deriving from an existing Structure subclass, ensure that you augment the list provided by the superclass, e.g.

           protected List getFieldOrder() {
               List fields = new ArrayList(super.getFieldOrder());
               fields.addAll(Arrays.asList(new String[] { ... }));
               return fields;
           }

      Field order must be explicitly indicated, since the field order as returned by `Class.getFields()` is not guaranteed to be predictable.
      Specified by:
        `getFieldOrder` in class `Structure`
      Returns:
        ordered list of field names

    - #### getLow

          public WinDef.DWORD getLow()

      Low DWORD.
      Returns:
        Low DWORD value

    - #### getHigh

          public WinDef.DWORD getHigh()

      High DWORD.
      Returns:
        High DWORD value

    - #### getValue

          public long getValue()

      64-bit value.
      Returns:
        The 64-bit value.

    - #### compareTo

          public int compareTo(WinNT.LARGE_INTEGER other)

      Specified by:
        `compareTo` in interface `java.lang.Comparable<WinNT.LARGE_INTEGER>`

    - #### toString

          public java.lang.String toString()

      Description copied from class: `Structure`
      If `jna.dump_memory` is true, will include a native memory dump of the Structure's backing memory.
      Overrides:
        `toString` in class `Structure`
      Returns:
        String representation of this object.

    - #### compare

          public static int compare(WinNT.LARGE_INTEGER v1,
                    WinNT.LARGE_INTEGER v2)

      Compares 2 LARGE_INTEGER 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)
      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 `getValue()`.
      See Also:
        `IntegerType.compare(long, long)`

    - #### compare

          public static int compare(WinNT.LARGE_INTEGER v1,
                    long v2)

      Compares a LARGE_INTEGER value with a `long` one. Note: if the LARGE_INTEGER value is `null` then it is consider greater than any `long` value.
      Parameters:
        `v1` - The `WinNT.LARGE_INTEGER` 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 `getValue()`.
      See Also:
        `IntegerType.compare(long, long)`

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