public enum ArrayType extends Enum<ArrayType>
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>.
| 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 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 |
| 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. |
public static final ArrayType BOOLEAN
public static final ArrayType BYTE
public static final ArrayType CHAR
public static final ArrayType SHORT
public static final ArrayType INT
public static final ArrayType LONG
public static final ArrayType FLOAT
public static final ArrayType DOUBLE
public static final ArrayType UBYTE
public static final ArrayType USHORT
public static final ArrayType UINT
public static final ArrayType ULONG
public static final ArrayType ENUM1
public static final ArrayType ENUM2
public static final ArrayType ENUM4
public static final ArrayType STRING
public static final ArrayType STRUCTURE
public static final ArrayType SEQUENCE
public static final ArrayType OPAQUE
@Deprecated public static final ArrayType OBJECT
public static ArrayType[] values()
for (ArrayType c : ArrayType.values()) System.out.println(c);
public static ArrayType valueOf(String name)
name - the name of the enum constant to be returned.IllegalArgumentException - if this enum type has no constant with the specified nameNullPointerException - if the argument is nullpublic String toNcml()
public String toCdl()
public int getSize()
public Class<?> getPrimitiveClass()
public ArrayType.Signedness getSignedness()
signedness of this data type.
For non-integral data types, it is guaranteed to be ArrayType.Signedness.SIGNED.public boolean isUnsigned()
true if the data type is unsigned.
For non-integral data types, it is guaranteed to be false.true if the data type is unsigned.public boolean isString()
public boolean isNumeric()
public boolean isIntegral()
public boolean isFloatingPoint()
public boolean isEnum()
public ArrayType withSignedness(ArrayType.Signedness signedness)
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
signedness - the desired signedness of the returned ArrayType.this, but with the specified signedness.@Deprecated public DataType getDataType()
@Nullable public static ArrayType getTypeByName(String name)
name - find ArrayType with this name.public static ArrayType forPrimitiveClass(Class<?> c, boolean isUnsigned)
public static Number widenNumber(Number number)
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 |
number - an integral number to treat as unsigned.public static Number widenNumberIfNegative(Number number)
widenNumber(java.lang.Number), but only integral types that are negative are widened.number - an integral number to treat as unsigned.public static BigInteger unsignedLongToBigInt(long l)
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.l - a long to treat as unsigned.BigInteger value.public static long unsignedIntToLong(int i)
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.i - an int to treat as unsigned.long value.public static int unsignedShortToInt(short s)
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.s - a short to treat as unsigned.int value.public static short unsignedByteToShort(byte b)
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.b - a byte to treat as unsigned.short value.