hdf.object.h4

## Class H4Datatype

- Object
- - hdf.object.HObject
  - - hdf.object.Datatype
    - - hdf.object.h4.H4Datatype

- All Implemented Interfaces:
    MetaDataContainer, Serializable

      public class H4Datatype
      extends Datatype

  This class defines HDF4 data type characteristics and APIs for a data type.

  This class provides several methods to convert an HDF4 datatype identifier to a datatype object, and vice versa. A datatype object is described by four basic fields: datatype class, size, byte order, and sign, while an HDF5 datatype is presented by a datatype identifier.

  Version:
    1.1 9/4/2007
  Author:
    Peter X. Cao
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class hdf.object.Datatype

      `arrayDims, baseType, CLASS_ARRAY, CLASS_BITFIELD, CLASS_CHAR, CLASS_COMPOUND, CLASS_ENUM, CLASS_FLOAT, CLASS_INTEGER, CLASS_NO_CLASS, CLASS_OPAQUE, CLASS_REFERENCE, CLASS_STRING, CLASS_TIME, CLASS_VLEN, compoundMemberNames, compoundMemberOffsets, compoundMemberTypes, datatypeClass, datatypeDescription, datatypeOrder, datatypeSign, datatypeSize, enumMembers, is_variable_str, is_VLEN, NATIVE, NSGN, ORDER_BE, ORDER_LE, ORDER_NONE, ORDER_VAX, SIGN_2, SIGN_NONE`

    - ### Fields inherited from class hdf.object.HObject

      `fileFormat, linkTargetObjName, oid, separator`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `H4Datatype(int tclass, int tsize, int torder, int tsign)` Constructs a H4Datatype with specified class, size, byte order and sign.
    `H4Datatype(long nativeID)` Constructs a H4Datatype with a given native datatype identifier.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static Object` | `allocateArray(long datatype, int datasize)` Allocate a 1D array large enough to hold a multidimensional array of 'datasize' elements of 'datatype' numbers.
    `void` | `close(long id)` Closes a datatype identifier.
    `long` | `createNative()` Converts the datatype object to a native datatype.
    `void` | `fromNative(long tid)` Set datatype characteristics (class, size, byte order and sign) from a given datatype identifier.
    `String` | `getDescription()` Returns a short text description of this datatype.
    `List` | `getMetadata(int... attrPropList)`
    `boolean` | `hasAttribute()` Check if the object has any attributes attached.
    `boolean` | `isText()`
    `boolean` | `isUnsigned()` Checks if this datatype is unsigned.
    `static boolean` | `isUnsigned(long datatype)` Checks if the datatype is an unsigned integer.

    - ### Methods inherited from class hdf.object.Datatype

      `getArrayDims, getCompoundMemberNames, getCompoundMemberTypes, getDatatypeBase, getDatatypeClass, getDatatypeOrder, getDatatypeSign, getDatatypeSize, getEnumMembers, getEnumMembersAsString, getMetadata, isArray, isBitField, isChar, isCompound, isEnum, isFloat, isInteger, isOpaque, isRef, isString, isVarStr, isVLEN, open, removeMetadata, setEnumMembers, toString, updateMetadata, writeMetadata`

    - ### Methods inherited from class hdf.object.HObject

      `debug, equals, equalsOID, getFID, getFile, getFileFormat, getFullName, getLinkTargetObjName, getName, getOID, getPath, setLinkTargetObjName, setName, setPath`

    - ### Methods inherited from class Object

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

- - ### Constructor Detail

    - #### H4Datatype

          public H4Datatype(int tclass,
                            int tsize,
                            int torder,
                            int tsign)

      Constructs a H4Datatype with specified class, size, byte order and sign.

      The following is a list of a few examples of H4Datatype:

      1. to create unsigned native integer
         H4Datatype type = new H4Dataype(CLASS_INTEGER, NATIVE, NATIVE, SIGN_NONE);
      2. to create 16-bit signed integer with big endian
         H4Datatype type = new H4Dataype(CLASS_INTEGER, 2, ORDER_BE, NATIVE);
      3. to create native float
         H4Datatype type = new H4Dataype(CLASS_FLOAT, NATIVE, NATIVE, -1);
      4. to create 64-bit double
         H4Datatype type = new H4Dataype(CLASS_FLOAT, 8, NATIVE, -1);
      Parameters:
        `tclass` - the class of the datatype, e.g. CLASS_INTEGER, CLASS_FLOAT and etc.
        `tsize` - the size of the datatype in bytes, e.g. for a 32-bit integer, the size is 4.
        `torder` - the byte order of the datatype. Valid values are ORDER_LE, ORDER_BE, ORDER_VAX and ORDER_NONE
        `tsign` - the sign of the datatype. Valid values are SIGN_NONE, SIGN_2 and MSGN

    - #### H4Datatype

          public H4Datatype(long nativeID)

      Constructs a H4Datatype with a given native datatype identifier.

      For example,

           Datatype dtype = new H4Datatype(HDFConstants.DFNT_INT32);

      will construct a datatype equivalent to

           new H4Datatype(CLASS_INTEGER, 4, NATIVE, SIGN_NONE);

      Parameters:
        `nativeID` - the native datatype identifier.
      See Also:
        `fromNative(long nativeID)`

  - ### Method Detail

    - #### hasAttribute

          public boolean hasAttribute()

      Description copied from interface: `MetaDataContainer`
      Check if the object has any attributes attached.
      Returns:
        true if it has any attributes, false otherwise.

    - #### fromNative

          public void fromNative(long tid)

      Description copied from class: `Datatype`
      Set datatype characteristics (class, size, byte order and sign) from a given datatype identifier.

      Sub-classes must implement it so that this datatype will be converted accordingly.

      For example, if the type identifier is a 64-bit unsigned integer created from HDF5,

           H5Datatype dtype = new H5Datatype();
           dtype.fromNative(HDF5Constants.H5T_NATIVE_UNINT32);

      Where dtype is equivalent to
      new H5Datatype(CLASS_INTEGER, 4, NATIVE, SIGN_NONE);
      Specified by:
        `fromNative` in class `Datatype`
      Parameters:
        `tid` - the datatype identifier.

    - #### allocateArray

          public static final Object allocateArray(long datatype,
                                                   int datasize)
                                            throws OutOfMemoryError

      Allocate a 1D array large enough to hold a multidimensional array of 'datasize' elements of 'datatype' numbers.
      Parameters:
        `datatype` - the data type
        `datasize` - the size of the data array
      Returns:
        an array of 'datasize' numbers of datatype.
      Throws:
        `OutOfMemoryError` - if the array cannot be allocated

    - #### getDescription

          public String getDescription()

      Description copied from class: `Datatype`
      Returns a short text description of this datatype.
      Overrides:
        `getDescription` in class `Datatype`
      Returns:
        a short text description of this datatype

    - #### isUnsigned

          public boolean isUnsigned()

      Description copied from class: `Datatype`
      Checks if this datatype is unsigned.
      Overrides:
        `isUnsigned` in class `Datatype`
      Returns:
        true if the datatype is unsigned; otherwise, returns false.

    - #### isUnsigned

          public static final boolean isUnsigned(long datatype)

      Checks if the datatype is an unsigned integer.
      Parameters:
        `datatype` - the data type.
      Returns:
        True is the datatype is an unsigned integer; otherwise returns false.

    - #### isText

          public boolean isText()

      Specified by:
        `isText` in class `Datatype`

    - #### createNative

          public long createNative()

      Description copied from class: `Datatype`
      Converts the datatype object to a native datatype. Subclasses must implement it so that this datatype will be converted accordingly. Use close() to close the native identifier; otherwise, the datatype will be left open.

      For example, a HDF5 datatype created from

           H5Dataype dtype = new H5Datatype(CLASS_INTEGER, 4, NATIVE, SIGN_NONE);
           int tid = dtype.createNative();

      The "tid" will be the HDF5 datatype id of a 64-bit unsigned integer, which is equivalent to

           int tid = H5.H5Tcopy(HDF5Constants.H5T_NATIVE_UNINT32);

      Specified by:
        `createNative` in class `Datatype`
      Returns:
        the identifier of the native datatype.

    - #### close

          public void close(long id)

      Description copied from class: `Datatype`
      Closes a datatype identifier.

      Sub-classes must replace this default implementation.

      Specified by:
        `close` in class `Datatype`
      Parameters:
        `id` - the datatype identifier to close.

    - #### getMetadata

          public List getMetadata(int... attrPropList)
                           throws Exception

      Throws:
        `Exception`

Copyright © 2018. All Rights Reserved.