ArrayType (cdm-core 6.0.0-beta1 API)

java.lang.Object
- java.lang.Enum<ArrayType>
- - ucar.array.ArrayType

All Implemented Interfaces:

Serializable, Comparable<ArrayType>
```
public enum ArrayType
extends Enum<ArrayType>
```
Type-safe enumeration of Array data types.
OPAQUE: Byte blobs, where length of blobs may be different. Usually stored as a vlen of Array<Byte>. If theres only one, may be just an Array<Byte>.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ArrayType.Signedness` A property of `integral` data types that determines whether they can represent both positive and negative numbers (signed), or only non-negative numbers (unsigned).

Enum Constant Summary

Enum Constants
Enum Constant and Description
`BOOLEAN`
`BYTE`
`CHAR`
`DOUBLE`
`ENUM1`
`ENUM2`
`ENUM4`
`FLOAT`
`INT`
`LONG`
`OBJECT` Deprecated. legacy, do not use.
`OPAQUE`
`SEQUENCE`
`SHORT`
`STRING`
`STRUCTURE`
`UBYTE`
`UINT`
`ULONG`
`USHORT`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static ArrayType`	`forPrimitiveClass(Class<?> c, boolean isUnsigned)` Find the ArrayType used for this primitive class type.
`DataType`	`getDataType()` Deprecated. do not use.
`Class<?>`	`getPrimitiveClass()` The primitive Java class type, inverse of forPrimitiveClass()
`ArrayType.Signedness`	`getSignedness()` Returns the `signedness` of this data type.
`int`	`getSize()` Size in bytes of one element of this data type.
`static ArrayType`	`getTypeByName(String name)` Find the ArrayType that matches this name.
`boolean`	`isEnum()` Is this an enumeration types?
`boolean`	`isFloatingPoint()` Is Float or Double
`boolean`	`isIntegral()` Is Byte, Int, Short, or Long
`boolean`	`isNumeric()` Is Byte, Float, Double, Int, Short, or Long
`boolean`	`isString()` Is String or Char
`boolean`	`isUnsigned()` Returns `true` if the data type is `unsigned`.
`String`	`toCdl()` The name used for CDL
`String`	`toNcml()` The name used for Ncml.
`String`	`toString()`
`static short`	`unsignedByteToShort(byte b)` Converts the argument to a `short` by an unsigned conversion.
`static long`	`unsignedIntToLong(int i)` Converts the argument to a `long` by an unsigned conversion.
`static BigInteger`	`unsignedLongToBigInt(long l)` Converts the argument to a `BigInteger` by an unsigned conversion.
`static int`	`unsignedShortToInt(short s)` Converts the argument to an `int` by an unsigned conversion.
`static ArrayType`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static ArrayType[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`static Number`	`widenNumber(Number number)` Convert the argument to the next largest integral data type by an unsigned conversion.
`static Number`	`widenNumberIfNegative(Number number)` This method is similar to `widenNumber(java.lang.Number)`, but only integral types that are negative are widened.
`ArrayType`	`withSignedness(ArrayType.Signedness signedness)` Returns an ArrayType that is related to `this`, but with the specified signedness.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf

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

- Enum Constant Detail
  - BOOLEAN
```
public static final ArrayType BOOLEAN
```
  - BYTE
```
public static final ArrayType BYTE
```
  - CHAR
```
public static final ArrayType CHAR
```
  - SHORT
```
public static final ArrayType SHORT
```
  - INT
```
public static final ArrayType INT
```
  - LONG
```
public static final ArrayType LONG
```
  - FLOAT
```
public static final ArrayType FLOAT
```
  - DOUBLE
```
public static final ArrayType DOUBLE
```
  - UBYTE
```
public static final ArrayType UBYTE
```
  - USHORT
```
public static final ArrayType USHORT
```
  - UINT
```
public static final ArrayType UINT
```
  - ULONG
```
public static final ArrayType ULONG
```
  - ENUM1
```
public static final ArrayType ENUM1
```
  - ENUM2
```
public static final ArrayType ENUM2
```
  - ENUM4
```
public static final ArrayType ENUM4
```
  - STRING
```
public static final ArrayType STRING
```
  - STRUCTURE
```
public static final ArrayType STRUCTURE
```
  - SEQUENCE
```
public static final ArrayType SEQUENCE
```
  - OPAQUE
```
public static final ArrayType OPAQUE
```
  - OBJECT
```
@Deprecated
public static final ArrayType OBJECT
```
    Deprecated. legacy, do not use.
- Method Detail
  - values
```
public static ArrayType[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (ArrayType c : ArrayType.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static ArrayType 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()
```
    Overrides:
    
    toString in class Enum<ArrayType>
  - toNcml
```
public String toNcml()
```
    The name used for Ncml.
  - toCdl
```
public String toCdl()
```
    The name used for CDL
  - 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.
  - getPrimitiveClass
```
public Class<?> getPrimitiveClass()
```
    The primitive Java class type, inverse of forPrimitiveClass()
  - getSignedness
```
public ArrayType.Signedness getSignedness()
```
    Returns the signedness of this data type. For non-integral data types, it is guaranteed to be ArrayType.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 ArrayType withSignedness(ArrayType.Signedness signedness)
```
    Returns an ArrayType 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 ArrayType.INT.withSignedness(ArrayType.Signedness.UNSIGNED) == ArrayType.UINT; // INT to UINT
 assert ArrayType.ULONG.withSignedness(ArrayType.Signedness.SIGNED) == ArrayType.LONG; // ULONG to LONG
 assert ArrayType.SHORT.withSignedness(ArrayType.Signedness.SIGNED) == ArrayType.SHORT; // this: Same signs
 assert ArrayType.STRING.withSignedness(ArrayType.Signedness.UNSIGNED) == ArrayType.STRING; // this: Non-integral
 
```
    Parameters:
    
    signedness - the desired signedness of the returned ArrayType.
    
    Returns:
    
    a ArrayType that is related to this, but with the specified signedness.
  - getDataType
```
@Deprecated
public DataType getDataType()
```
    Deprecated. do not use.
  - getTypeByName
```
@Nullable
public static ArrayType getTypeByName(String name)
```
    Find the ArrayType that matches this name.
    
    Parameters:
    
    name - find ArrayType with this name.
    
    Returns:
    
    ArrayType or null if no match.
  - forPrimitiveClass
```
public static ArrayType forPrimitiveClass(Class<?> c,
                                          boolean isUnsigned)
```
    Find the ArrayType used for this primitive class type.
  - 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 2⁶⁴.
    
    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 2³².
    
    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 2¹⁶.
    
    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 2⁸.
    
    Parameters:
    
    b - a byte to treat as unsigned.
    
    Returns:
    
    the equivalent short value.

Argument type	Result type
Byte	Short
Short	Integer
Integer	Long
Long	BigInteger
Any other Number subtype	Just return argument

Enum ArrayType

Nested Class Summary

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

BOOLEAN

BYTE

CHAR

SHORT

INT

LONG

FLOAT

DOUBLE

UBYTE

USHORT

UINT

ULONG

ENUM1

ENUM2

ENUM4

STRING

STRUCTURE

SEQUENCE

OPAQUE

OBJECT

Method Detail

values

valueOf

toString

toNcml

toCdl

getSize

getPrimitiveClass

getSignedness

isUnsigned

isString

isNumeric

isIntegral

isFloatingPoint

isEnum

withSignedness

getDataType

getTypeByName

forPrimitiveClass

widenNumber

widenNumberIfNegative

unsignedLongToBigInt

unsignedIntToLong

unsignedShortToInt

unsignedByteToShort