Package ucar.ma2

Enum DataType

java.lang.Object
java.lang.Enum<DataType>
ucar.ma2.DataType
All Implemented Interfaces:
Serializable, Comparable<DataType>
public enum DataType extends Enum<DataType>
Type-safe enumeration of data types. Do not change the ordering of these enums, as they are used in protobuf messages, only add new ones onto the end.

  • Enum Constant Details

    • BOOLEAN

      public static final DataType BOOLEAN

    • BYTE

      public static final DataType BYTE

    • CHAR

      public static final DataType CHAR

    • SHORT

      public static final DataType SHORT

    • INT

      public static final DataType INT

    • LONG

      public static final DataType LONG

    • FLOAT

      public static final DataType FLOAT

    • DOUBLE

      public static final DataType DOUBLE

    • SEQUENCE

      public static final DataType SEQUENCE

    • STRING

      public static final DataType STRING

    • STRUCTURE

      public static final DataType STRUCTURE

    • ENUM1

      public static final DataType ENUM1

    • ENUM2

      public static final DataType ENUM2

    • ENUM4

      public static final DataType ENUM4

    • OPAQUE

      public static final DataType OPAQUE

    • OBJECT

      public static final DataType OBJECT

    • UBYTE

      public static final DataType UBYTE

    • USHORT

      public static final DataType USHORT

    • UINT

      public static final DataType UINT

    • ULONG

      public static final DataType ULONG

  • Method Details

    • values

      public static DataType[] values()
      Returns an array containing the constants of this enum type, in the order they are declared.
      Returns:
      an array containing the constants of this enum type, in the order they are declared

    • valueOf

      public static DataType valueOf(String name)
      Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
      Parameters:
      name - the name of the enum constant to be returned.
      Returns:
      the enum constant with the specified name
      Throws:
      IllegalArgumentException - if this enum type has no constant with the specified name
      NullPointerException - if the argument is null

    • toString

      public String toString()
      The DataType name, eg "byte", "float", "String".
      Overrides:
      toString in class Enum<DataType>

    • getSize

      public int getSize()
      Size in bytes of one element of this data type. Strings dont know, so return 0. Structures return 1.
      Returns:
      Size in bytes of one element of this data type.

    • getPrimitiveClassType

      public Class getPrimitiveClassType()
      The primitive class type: char, byte, float, double, short, int, long, boolean, String, StructureData, StructureDataIterator, ByteBuffer.
      Returns:
      the primitive class type

    • getSignedness

      public DataType.Signedness getSignedness()
      Returns the signedness of this data type. For non-integral data types, it is guaranteed to be DataType.Signedness.SIGNED.
      Returns:
      the signedness of this data type.

    • isUnsigned

      public boolean isUnsigned()
      Returns true if the data type is unsigned. For non-integral data types, it is guaranteed to be false.
      Returns:
      true if the data type is unsigned.

    • isString

      public boolean isString()
      Is String or Char
      Returns:
      true if String or Char

    • isNumeric

      public boolean isNumeric()
      Is Byte, Float, Double, Int, Short, or Long
      Returns:
      true if numeric

    • isIntegral

      public boolean isIntegral()
      Is Byte, Int, Short, or Long
      Returns:
      true if integral

    • isFloatingPoint

      public boolean isFloatingPoint()
      Is Float or Double
      Returns:
      true if floating point type

    • isEnum

      public boolean isEnum()
      Is this an enumeration types?
      Returns:
      true if ENUM1, 2, or 4

    • withSignedness

      public DataType withSignedness(DataType.Signedness signedness)
      Returns a DataType that is related to this, but with the specified signedness. This method is only meaningful for integral data types; if it is called on a non-integral type, then this is simply returned. Examples: 
       assert DataType.INT.withSignedness(DataType.Signedness.UNSIGNED) == DataType.UINT; // INT to UINT
 assert DataType.ULONG.withSignedness(DataType.Signedness.SIGNED) == DataType.LONG; // ULONG to LONG
 assert DataType.SHORT.withSignedness(DataType.Signedness.SIGNED) == DataType.SHORT; // this: Same signs
 assert DataType.STRING.withSignedness(DataType.Signedness.UNSIGNED) == DataType.STRING; // this: Non-integral
      Parameters:
      signedness - the desired signedness of the returned DataType.
      Returns:
      a DataType that is related to this, but with the specified signedness.

    • isEnumCompatible

      public boolean isEnumCompatible(DataType inferred)

    • enumTypeize

      public static DataType enumTypeize(DataType dt)

    • getType

      public static DataType getType(String name)
      Find the DataType that matches this name.
      Parameters:
      name - find DataType with this name.
      Returns:
      DataType or null if no match.

    • getType

      public static DataType getType(Array arr)

    • getType

      public static DataType getType(Class c, boolean isUnsigned)
      Find the DataType that matches this class.
      Parameters:
      c - primitive or object class, eg float.class or Float.class
      Returns:
      DataType or null if no match.

    • widenNumber

      public static Number widenNumber(Number number)
      Convert the argument to the next largest integral data type by an unsigned conversion. In the larger data type, the upper-order bits will be zero, and the lower-order bits will be equivalent to the bits in number. Thus, we are "widening" the argument by prepending a bunch of zero bits to it.

      This widening operation is intended to be used on unsigned integral values that are being stored within one of Java's signed, integral data types. For example, if we have the bit pattern "11001010" and treat it as an unsigned byte, it'll have the decimal value "202". However, if we store that bit pattern in a (signed) byte, Java will interpret it as "-52". Widening the byte to a short will mean that the most-significant set bit is no longer the sign bit, and thus Java will no longer consider the value to be negative.

      Argument type Result type
      Byte Short
      Short Integer
      Integer Long
      Long BigInteger
      Any other Number subtype Just return argument
      Parameters:
      number - an integral number to treat as unsigned.
      Returns:
      an equivalent but wider value that Java will interpret as non-negative.

    • widenNumberIfNegative

      public static Number widenNumberIfNegative(Number number)
      This method is similar to widenNumber(java.lang.Number), but only integral types that are negative are widened.
      Parameters:
      number - an integral number to treat as unsigned.
      Returns:
      an equivalent value that Java will interpret as non-negative.

    • unsignedLongToBigInt

      public static BigInteger unsignedLongToBigInt(long l)
      Converts the argument to a BigInteger by an unsigned conversion. In an unsigned conversion to a BigInteger, zero and positive long values are mapped to a numerically equal BigInteger value and negative long values are mapped to a BigInteger value equal to the input plus 264.
      Parameters:
      l - a long to treat as unsigned.
      Returns:
      the equivalent BigInteger value.

    • unsignedIntToLong

      public static long unsignedIntToLong(int i)
      Converts the argument to a long by an unsigned conversion. In an unsigned conversion to a long, the high-order 32 bits of the long are zero and the low-order 32 bits are equal to the bits of the integer argument. Consequently, zero and positive int values are mapped to a numerically equal long value and negative int values are mapped to a long value equal to the input plus 232.
      Parameters:
      i - an int to treat as unsigned.
      Returns:
      the equivalent long value.

    • unsignedShortToInt

      public static int unsignedShortToInt(short s)
      Converts the argument to an int by an unsigned conversion. In an unsigned conversion to an int, the high-order 16 bits of the int are zero and the low-order 16 bits are equal to the bits of the short argument. Consequently, zero and positive short values are mapped to a numerically equal int value and negative short values are mapped to an int value equal to the input plus 216.
      Parameters:
      s - a short to treat as unsigned.
      Returns:
      the equivalent int value.

    • unsignedByteToShort

      public static short unsignedByteToShort(byte b)
      Converts the argument to a short by an unsigned conversion. In an unsigned conversion to a short, the high-order 8 bits of the short are zero and the low-order 8 bits are equal to the bits of the byte argument. Consequently, zero and positive byte values are mapped to a numerically equal short value and negative byte values are mapped to a short value equal to the input plus 28.
      Parameters:
      b - a byte to treat as unsigned.
      Returns:
      the equivalent short value.