OpenJDK 1.23 · javax.management.openmbean.ArrayType · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
private int	dimension
private OpenType<?>	elementType
private transient Integer	myHashCode
private transient String	myToString
private static final Object[][]	PRIMITIVE_ARRAY_TYPES
private static final int	PRIMITIVE_OPEN_TYPE_INDEX
private static final int	PRIMITIVE_TYPE_KEY_INDEX
private static final int	PRIMITIVE_TYPE_NAME_INDEX
private static final int	PRIMITIVE_WRAPPER_NAME_INDEX
private boolean	primitiveArray
pack-priv static final long	serialVersionUID Hides javax.management.openmbean.OpenType.serialVersionUID.

Access	Constructor and Description
public	ArrayType(int the dimension of arrays described by this `ArrayType` instance; must be greater than or equal to 1. dimension, OpenType<?> the open type of element values contained in the arrays described by this `ArrayType` instance; must be an instance of either `SimpleType`, `CompositeType`, `TabularType` or another `ArrayType` with a `SimpleType`, `CompositeType` or `TabularType` as its `elementType`. elementType) Constructs an `ArrayType` instance describing open data values which are arrays with dimension `dimension` of elements whose open type is `elementType`.
public	ArrayType(SimpleType<?> the `SimpleType` of the element values contained in the arrays described by this `ArrayType` instance. elementType, boolean `true` when this array describes primitive arrays. primitiveArray) Constructs a unidimensional `ArrayType` instance for the supplied `SimpleType`.
pack-priv	ArrayType(String className, String typeName, String description, int dimension, OpenType<?> elementType, boolean primitiveArray)

Method Summary

Modifier and Type	Method and Description
private static String	buildArrayClassName(int dimension, OpenType<?> elementType)
private static String	buildArrayClassName(int dimension, OpenType<?> elementType, boolean isPrimitiveArray)
private static String	buildArrayDescription(int dimension, OpenType<?> elementType)
private static String	buildArrayDescription(int dimension, OpenType<?> elementType, boolean isPrimitiveArray)
private boolean	checkElementsType(Object[] x_dim_Array, int dim) Returns true if and only if all elements contained in the array argument x_dim_Array of dimension dim are valid values (ie either null or of the right openType) for the element open type specified by this ArrayType instance.
private <T> ArrayType<T>	convertFromPrimitiveToWrapperTypes()
private <T> ArrayType<T>	convertFromWrapperToPrimitiveTypes()
public boolean	Returns: `true` if the specified object is equal to this `ArrayType` instance. equals(Object the object to be compared for equality with this `ArrayType` instance; if `obj` is `null` or is not an instance of the class `ArrayType` this method returns `false`. obj) Implements abstract javax.management.openmbean.OpenType.equals. Compares the specified `obj` parameter with this `ArrayType` instance for equality.
public static < the Java type that described instances must have E> ArrayType<E[]>	Returns: an `ArrayType` instance getArrayType(OpenType<E> the open type of element values contained in the arrays described by this `ArrayType` instance; must be an instance of either `SimpleType`, `CompositeType`, `TabularType` or another `ArrayType` with a `SimpleType`, `CompositeType` or `TabularType` as its `elementType`. elementType) Create an `ArrayType` instance in a type-safe manner.
public int	Returns: the dimension. getDimension() Returns the dimension of arrays described by this `ArrayType` instance.
public OpenType<?>	Returns: the element type. getElementOpenType() Returns the open type of element values contained in the arrays described by this `ArrayType` instance.
public static < the Java type that described instances must have T> ArrayType<T>	Returns: an `ArrayType` instance getPrimitiveArrayType(Class<T> a primitive array class such as `int[].class`, `boolean[][].class`, etc. The `getElementOpenType()` method of the returned `ArrayType` returns the `SimpleType` corresponding to the wrapper type of the primitive type of the array. arrayClass) Create an `ArrayType` instance in a type-safe manner.
pack-priv static SimpleType<?>	Returns: the OpenType corresponding to the given primitive type name (SimpleType.BOOLEAN, SimpleType.CHARACTER, etc...) return null if the given elementClassName is not a primitive type name. getPrimitiveOpenType(String the primitive type of the array element ("boolean", "char", etc...) primitiveTypeName) Return the primitive open type corresponding to the given primitive type.
pack-priv static String	Returns: the key corresponding to the given type ("Z", "C", etc...) return null if the given elementClassName is not a primitive wrapper class name. getPrimitiveTypeKey(String the wrapper class name of the array element ("Boolean", "Character", etc...) elementClassName) Return the key used to identify the element type in arrays - e.g. "Z" for boolean, "C" for char etc...
pack-priv static String	Returns: the primitive type name corresponding to the given wrapper class ("boolean", "char", etc...) return null if the given elementClassName is not a primitive wrapper type name. getPrimitiveTypeName(String the type of the array element ("Boolean", "Character", etc...) elementClassName) Return the primitive type name corresponding to the given wrapper class.
public int	Returns: the hash code value for this `ArrayType` instance hashCode() Implements abstract javax.management.openmbean.OpenType.hashCode. Returns the hash code value for this `ArrayType` instance.
pack-priv boolean	isAssignableFrom(OpenType<?> the type to be tested. ot) Overrides javax.management.openmbean.OpenType.isAssignableFrom. Tests whether values of the given type can be assigned to this open type.
public boolean	Returns: true if this is a primitive array type. isPrimitiveArray() Returns `true` if the open data values this open type describes are primitive arrays, `false` otherwise.
pack-priv static boolean	isPrimitiveContentType(final String primitiveKey)
public boolean	Returns: `true` if `obj` is a value for this `ArrayType` instance. isValue(Object the object to be tested. obj) Implements abstract javax.management.openmbean.OpenType.isValue. Tests whether `obj` is a value for this `ArrayType` instance.
private Object	readResolve() Replace/resolve the object read from the stream before it is returned to the caller.
public String	Returns: a string representation of this `ArrayType` instance toString() Implements abstract javax.management.openmbean.OpenType.toString. Returns a string representation of this `ArrayType` instance.
private Object	writeReplace() Nominate a replacement for this object in the stream before the object is written.

Inherited from javax.management.openmbean.OpenType:: getClassName getDescription getDescriptor getTypeName isArray safeGetClassName

Field Detail

dimension	back to summary
private int dimension

elementType	back to summary
private OpenType<?> elementType

myHashCode	back to summary
private transient Integer myHashCode

myToString	back to summary
private transient String myToString

PRIMITIVE_ARRAY_TYPES	back to summary
private static final Object[][] PRIMITIVE_ARRAY_TYPES

PRIMITIVE_OPEN_TYPE_INDEX	back to summary
private static final int PRIMITIVE_OPEN_TYPE_INDEX

PRIMITIVE_TYPE_KEY_INDEX	back to summary
private static final int PRIMITIVE_TYPE_KEY_INDEX

PRIMITIVE_TYPE_NAME_INDEX	back to summary
private static final int PRIMITIVE_TYPE_NAME_INDEX

PRIMITIVE_WRAPPER_NAME_INDEX	back to summary
private static final int PRIMITIVE_WRAPPER_NAME_INDEX

primitiveArray	back to summary
private boolean primitiveArray Since 1.6

serialVersionUID	back to summary
pack-priv static final long serialVersionUID Hides javax.management.openmbean.OpenType.serialVersionUID.

Constructor Detail

ArrayType back to summary

ArrayType	back to summary
public ArrayType(int dimension, OpenType<?> elementType) throws OpenDataException Constructs an `ArrayType` instance describing open data values which are arrays with dimension `dimension` of elements whose open type is `elementType`. When invoked on an `ArrayType` instance, the `getClassName` method returns the class name of the array instances it describes (following the rules defined by the `getName` method of `java.lang.Class`), not the class name of the array elements (which is returned by a call to `getElementOpenType().getClassName()`). The internal field corresponding to the type name of this `ArrayType` instance is also set to the class name of the array instances it describes. In other words, the methods `getClassName` and `getTypeName` return the same string value. The internal field corresponding to the description of this `ArrayType` instance is set to a string value which follows the following template: if non-primitive array: `<dimension>-dimension array of <element_class_name>` if primitive array: `<dimension>-dimension array of <primitive_type_of_the_element_class_name>` As an example, the following piece of code: `ArrayType<String[][][]> t = new ArrayType<String[][][]>(3, SimpleType.STRING); System.out.println("array class name = " + t.getClassName()); System.out.println("element class name = " + t.getElementOpenType().getClassName()); System.out.println("array type name = " + t.getTypeName()); System.out.println("array type description = " + t.getDescription());` would produce the following output: `array class name = [[[Ljava.lang.String; element class name = java.lang.String array type name = [[[Ljava.lang.String; array type description = 3-dimension array of java.lang.String` And the following piece of code which is equivalent to the one listed above would also produce the same output: `ArrayType<String[]> t1 = new ArrayType<String[]>(1, SimpleType.STRING); ArrayType<String[][]> t2 = new ArrayType<String[][]>(1, t1); ArrayType<String[][][]> t3 = new ArrayType<String[][][]>(1, t2); System.out.println("array class name = " + t3.getClassName()); System.out.println("element class name = " + t3.getElementOpenType().getClassName()); System.out.println("array type name = " + t3.getTypeName()); System.out.println("array type description = " + t3.getDescription());` Parameters dimension:int the dimension of arrays described by this `ArrayType` instance; must be greater than or equal to 1. elementType:OpenType<?> the open type of element values contained in the arrays described by this `ArrayType` instance; must be an instance of either `SimpleType`, `CompositeType`, `TabularType` or another `ArrayType` with a `SimpleType`, `CompositeType` or `TabularType` as its `elementType`. Exceptions OpenDataException: if `elementType's className` is not one of the allowed Java class names for open data. IllegalArgumentException: if `dimension` is not a positive integer.

public ArrayType(int dimension, OpenType<?> elementType) throws OpenDataException

Constructs an ArrayType instance describing open data values which are arrays with dimension dimension of elements whose open type is elementType.

When invoked on an ArrayType instance, the getClassName method returns the class name of the array instances it describes (following the rules defined by the getName method of java.lang.Class), not the class name of the array elements (which is returned by a call to getElementOpenType().getClassName()).

The internal field corresponding to the type name of this ArrayType instance is also set to the class name of the array instances it describes. In other words, the methods getClassName and getTypeName return the same string value. The internal field corresponding to the description of this ArrayType instance is set to a string value which follows the following template:

if non-primitive array: <dimension>-dimension array of <element_class_name>
if primitive array: <dimension>-dimension array of <primitive_type_of_the_element_class_name>

As an example, the following piece of code:

ArrayType<String[][][]> t = new ArrayType<String[][][]>(3, SimpleType.STRING);
System.out.println("array class name       = " + t.getClassName());
System.out.println("element class name     = " + t.getElementOpenType().getClassName());
System.out.println("array type name        = " + t.getTypeName());
System.out.println("array type description = " + t.getDescription());

would produce the following output:

array class name       = [[[Ljava.lang.String;
element class name     = java.lang.String
array type name        = [[[Ljava.lang.String;
array type description = 3-dimension array of java.lang.String

And the following piece of code which is equivalent to the one listed above would also produce the same output:

ArrayType<String[]> t1 = new ArrayType<String[]>(1, SimpleType.STRING);
ArrayType<String[][]> t2 = new ArrayType<String[][]>(1, t1);
ArrayType<String[][][]> t3 = new ArrayType<String[][][]>(1, t2);
System.out.println("array class name       = " + t3.getClassName());
System.out.println("element class name     = " + t3.getElementOpenType().getClassName());
System.out.println("array type name        = " + t3.getTypeName());
System.out.println("array type description = " + t3.getDescription());

Parameters

dimension:int: the dimension of arrays described by this ArrayType instance; must be greater than or equal to 1.
elementType:OpenType<?>: the open type of element values contained in the arrays described by this ArrayType instance; must be an instance of either SimpleType, CompositeType, TabularType or another ArrayType with a SimpleType, CompositeType or TabularType as its elementType.

Exceptions

OpenDataException:: if elementType's className is not one of the allowed Java class names for open data.
IllegalArgumentException:: if dimension is not a positive integer.

ArrayType back to summary

ArrayType	back to summary
public ArrayType(SimpleType<?> elementType, boolean primitiveArray) throws OpenDataException Constructs a unidimensional `ArrayType` instance for the supplied `SimpleType`. This constructor supports the creation of arrays of primitive types when `primitiveArray` is `true`. For primitive arrays the `getElementOpenType()` method returns the `SimpleType` corresponding to the wrapper type of the primitive type of the array. When invoked on an `ArrayType` instance, the `getClassName` method returns the class name of the array instances it describes (following the rules defined by the `getName` method of `java.lang.Class`), not the class name of the array elements (which is returned by a call to `getElementOpenType().getClassName()`). The internal field corresponding to the type name of this `ArrayType` instance is also set to the class name of the array instances it describes. In other words, the methods `getClassName` and `getTypeName` return the same string value. The internal field corresponding to the description of this `ArrayType` instance is set to a string value which follows the following template: if non-primitive array: `1-dimension array of <element_class_name>` if primitive array: `1-dimension array of <primitive_type_of_the_element_class_name>` As an example, the following piece of code: `ArrayType<int[]> t = new ArrayType<int[]>(SimpleType.INTEGER, true); System.out.println("array class name = " + t.getClassName()); System.out.println("element class name = " + t.getElementOpenType().getClassName()); System.out.println("array type name = " + t.getTypeName()); System.out.println("array type description = " + t.getDescription());` would produce the following output: `array class name = [I element class name = java.lang.Integer array type name = [I array type description = 1-dimension array of int` Parameters elementType:SimpleType<?> the `SimpleType` of the element values contained in the arrays described by this `ArrayType` instance. primitiveArray:boolean `true` when this array describes primitive arrays. Exceptions OpenDataException: if `primitiveArray` is `true` and `elementType` is not a valid `SimpleType` for a primitive type. IllegalArgumentException: if `dimension` is not a positive integer. Since 1.6

public ArrayType(SimpleType<?> elementType, boolean primitiveArray) throws OpenDataException

Constructs a unidimensional ArrayType instance for the supplied SimpleType.

This constructor supports the creation of arrays of primitive types when primitiveArray is true.

For primitive arrays the getElementOpenType() method returns the SimpleType corresponding to the wrapper type of the primitive type of the array.

if non-primitive array: 1-dimension array of <element_class_name>
if primitive array: 1-dimension array of <primitive_type_of_the_element_class_name>

As an example, the following piece of code:

ArrayType<int[]> t = new ArrayType<int[]>(SimpleType.INTEGER, true);
System.out.println("array class name       = " + t.getClassName());
System.out.println("element class name     = " + t.getElementOpenType().getClassName());
System.out.println("array type name        = " + t.getTypeName());
System.out.println("array type description = " + t.getDescription());

would produce the following output:

array class name       = [I
element class name     = java.lang.Integer
array type name        = [I
array type description = 1-dimension array of int

Parameters

elementType:SimpleType<?>: the SimpleType of the element values contained in the arrays described by this ArrayType instance.
primitiveArray:boolean: true when this array describes primitive arrays.

Exceptions

OpenDataException:: if primitiveArray is true and elementType is not a valid SimpleType for a primitive type.
IllegalArgumentException:: if dimension is not a positive integer.

Since

1.6

ArrayType	back to summary
pack-priv ArrayType(String className, String typeName, String description, int dimension, OpenType<?> elementType, boolean primitiveArray)

Method Detail

buildArrayClassName	back to summary
private static String buildArrayClassName(int dimension, OpenType<?> elementType) throws OpenDataException

buildArrayClassName	back to summary
private static String buildArrayClassName(int dimension, OpenType<?> elementType, boolean isPrimitiveArray) throws OpenDataException

buildArrayDescription	back to summary
private static String buildArrayDescription(int dimension, OpenType<?> elementType) throws OpenDataException

buildArrayDescription	back to summary
private static String buildArrayDescription(int dimension, OpenType<?> elementType, boolean isPrimitiveArray) throws OpenDataException

checkElementsType	back to summary
private boolean checkElementsType(Object[] x_dim_Array, int dim) Returns true if and only if all elements contained in the array argument x_dim_Array of dimension dim are valid values (ie either null or of the right openType) for the element open type specified by this ArrayType instance. This method's implementation uses recursion to go down the dimensions of the array argument.

convertFromPrimitiveToWrapperTypes	back to summary
private <T> ArrayType<T> convertFromPrimitiveToWrapperTypes()

convertFromWrapperToPrimitiveTypes	back to summary
private <T> ArrayType<T> convertFromWrapperToPrimitiveTypes()

equals back to summary

equals	back to summary
public boolean equals(Object obj) Implements abstract javax.management.openmbean.OpenType.equals. Compares the specified `obj` parameter with this `ArrayType` instance for equality. Two `ArrayType` instances are equal if and only if they describe array instances which have the same dimension, elements' open type and primitive array flag. Parameters obj:Object the object to be compared for equality with this `ArrayType` instance; if `obj` is `null` or is not an instance of the class `ArrayType` this method returns `false`. Returns:boolean `true` if the specified object is equal to this `ArrayType` instance.

public boolean equals(Object obj)

Implements abstract javax.management.openmbean.OpenType.equals.

Compares the specified obj parameter with this ArrayType instance for equality.

Two ArrayType instances are equal if and only if they describe array instances which have the same dimension, elements' open type and primitive array flag.

Parameters

obj:Object: the object to be compared for equality with this ArrayType instance; if obj is null or is not an instance of the class ArrayType this method returns false.

Returns:boolean

true if the specified object is equal to this ArrayType instance.

getArrayType back to summary

getArrayType	back to summary
public static <E> ArrayType<E[]> getArrayType(OpenType<E> elementType) throws OpenDataException Create an `ArrayType` instance in a type-safe manner. Multidimensional arrays can be built up by calling this method as many times as necessary. Calling this method twice with the same parameters may return the same object or two equal but not identical objects. As an example, the following piece of code: `ArrayType<String[]> t1 = ArrayType.getArrayType(SimpleType.STRING); ArrayType<String[][]> t2 = ArrayType.getArrayType(t1); ArrayType<String[][][]> t3 = ArrayType.getArrayType(t2); System.out.println("array class name = " + t3.getClassName()); System.out.println("element class name = " + t3.getElementOpenType().getClassName()); System.out.println("array type name = " + t3.getTypeName()); System.out.println("array type description = " + t3.getDescription());` would produce the following output: `array class name = [[[Ljava.lang.String; element class name = java.lang.String array type name = [[[Ljava.lang.String; array type description = 3-dimension array of java.lang.String` Parameters <E> the Java type that described instances must have elementType:OpenType<E> the open type of element values contained in the arrays described by this `ArrayType` instance; must be an instance of either `SimpleType`, `CompositeType`, `TabularType` or another `ArrayType` with a `SimpleType`, `CompositeType` or `TabularType` as its `elementType`. Returns:ArrayType<E[]> an `ArrayType` instance Exceptions OpenDataException: if `elementType's className` is not one of the allowed Java class names for open data. Since 1.6

public static <E> ArrayType<E[]> getArrayType(OpenType<E> elementType) throws OpenDataException

Create an ArrayType instance in a type-safe manner.

Multidimensional arrays can be built up by calling this method as many times as necessary.

Calling this method twice with the same parameters may return the same object or two equal but not identical objects.

As an example, the following piece of code:

ArrayType<String[]> t1 = ArrayType.getArrayType(SimpleType.STRING);
ArrayType<String[][]> t2 = ArrayType.getArrayType(t1);
ArrayType<String[][][]> t3 = ArrayType.getArrayType(t2);
System.out.println("array class name       = " + t3.getClassName());
System.out.println("element class name     = " + t3.getElementOpenType().getClassName());
System.out.println("array type name        = " + t3.getTypeName());
System.out.println("array type description = " + t3.getDescription());

would produce the following output:

array class name       = [[[Ljava.lang.String;
element class name     = java.lang.String
array type name        = [[[Ljava.lang.String;
array type description = 3-dimension array of java.lang.String

Parameters

<E>: the Java type that described instances must have
elementType:OpenType<E>: the open type of element values contained in the arrays described by this ArrayType instance; must be an instance of either SimpleType, CompositeType, TabularType or another ArrayType with a SimpleType, CompositeType or TabularType as its elementType.

Returns:ArrayType<E[]>

an ArrayType instance

Exceptions

OpenDataException:: if elementType's className is not one of the allowed Java class names for open data.

Since

1.6

getDimension back to summary

getDimension	back to summary
public int getDimension() Returns the dimension of arrays described by this `ArrayType` instance. Returns:int the dimension.

public int getDimension()

Returns the dimension of arrays described by this ArrayType instance.

Returns:int: the dimension.

getElementOpenType back to summary

getElementOpenType	back to summary
public OpenType<?> getElementOpenType() Returns the open type of element values contained in the arrays described by this `ArrayType` instance. Returns:OpenType<?> the element type.

public OpenType<?> getElementOpenType()

Returns the open type of element values contained in the arrays described by this ArrayType instance.

Returns:OpenType<?>: the element type.

getPrimitiveArrayType back to summary

getPrimitiveArrayType	back to summary
public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> arrayClass) Create an `ArrayType` instance in a type-safe manner. Calling this method twice with the same parameters may return the same object or two equal but not identical objects. As an example, the following piece of code: `ArrayType<int[][][]> t = ArrayType.getPrimitiveArrayType(int[][][].class); System.out.println("array class name = " + t.getClassName()); System.out.println("element class name = " + t.getElementOpenType().getClassName()); System.out.println("array type name = " + t.getTypeName()); System.out.println("array type description = " + t.getDescription());` would produce the following output: `array class name = [[[I element class name = java.lang.Integer array type name = [[[I array type description = 3-dimension array of int` Parameters <T> the Java type that described instances must have arrayClass:Class<T> a primitive array class such as `int[].class`, `boolean[][].class`, etc. The `getElementOpenType()` method of the returned `ArrayType` returns the `SimpleType` corresponding to the wrapper type of the primitive type of the array. Returns:ArrayType<T> an `ArrayType` instance Annotations @SuppressWarnings:unchecked Exceptions IllegalArgumentException: if `arrayClass` is not a primitive array. Since 1.6

public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> arrayClass)

Create an ArrayType instance in a type-safe manner.

Calling this method twice with the same parameters may return the same object or two equal but not identical objects.

As an example, the following piece of code:

ArrayType<int[][][]> t = ArrayType.getPrimitiveArrayType(int[][][].class);
System.out.println("array class name       = " + t.getClassName());
System.out.println("element class name     = " + t.getElementOpenType().getClassName());
System.out.println("array type name        = " + t.getTypeName());
System.out.println("array type description = " + t.getDescription());

would produce the following output:

array class name       = [[[I
element class name     = java.lang.Integer
array type name        = [[[I
array type description = 3-dimension array of int

Parameters

<T>: the Java type that described instances must have
arrayClass:Class<T>: a primitive array class such as int[].class, boolean[][].class, etc. The getElementOpenType() method of the returned ArrayType returns the SimpleType corresponding to the wrapper type of the primitive type of the array.

Returns:ArrayType<T>

an ArrayType instance

Annotations

@SuppressWarnings:unchecked

Exceptions

IllegalArgumentException:: if arrayClass is not a primitive array.

Since

1.6

getPrimitiveOpenType	back to summary
pack-priv static SimpleType<?> getPrimitiveOpenType(String primitiveTypeName) Return the primitive open type corresponding to the given primitive type. e.g. SimpleType.BOOLEAN for "boolean", SimpleType.CHARACTER for "char", etc... Parameters primitiveTypeName:String the primitive type of the array element ("boolean", "char", etc...) Returns:SimpleType<?> the OpenType corresponding to the given primitive type name (SimpleType.BOOLEAN, SimpleType.CHARACTER, etc...) return null if the given elementClassName is not a primitive type name.

getPrimitiveOpenType

back to summary

pack-priv static SimpleType<?> getPrimitiveOpenType(String primitiveTypeName)

Return the primitive open type corresponding to the given primitive type. e.g. SimpleType.BOOLEAN for "boolean", SimpleType.CHARACTER for "char", etc...

Parameters

primitiveTypeName:String: the primitive type of the array element ("boolean", "char", etc...)

Returns:SimpleType<?>

the OpenType corresponding to the given primitive type name (SimpleType.BOOLEAN, SimpleType.CHARACTER, etc...) return null if the given elementClassName is not a primitive type name.

getPrimitiveTypeKey	back to summary
pack-priv static String getPrimitiveTypeKey(String elementClassName) Return the key used to identify the element type in arrays - e.g. "Z" for boolean, "C" for char etc... Parameters elementClassName:String the wrapper class name of the array element ("Boolean", "Character", etc...) Returns:String the key corresponding to the given type ("Z", "C", etc...) return null if the given elementClassName is not a primitive wrapper class name.

getPrimitiveTypeKey

back to summary

pack-priv static String getPrimitiveTypeKey(String elementClassName)

Return the key used to identify the element type in arrays - e.g. "Z" for boolean, "C" for char etc...

Parameters

elementClassName:String: the wrapper class name of the array element ("Boolean", "Character", etc...)

Returns:String

the key corresponding to the given type ("Z", "C", etc...) return null if the given elementClassName is not a primitive wrapper class name.

getPrimitiveTypeName	back to summary
pack-priv static String getPrimitiveTypeName(String elementClassName) Return the primitive type name corresponding to the given wrapper class. e.g. "boolean" for "Boolean", "char" for "Character" etc... Parameters elementClassName:String the type of the array element ("Boolean", "Character", etc...) Returns:String the primitive type name corresponding to the given wrapper class ("boolean", "char", etc...) return null if the given elementClassName is not a primitive wrapper type name.

getPrimitiveTypeName

back to summary

pack-priv static String getPrimitiveTypeName(String elementClassName)

Return the primitive type name corresponding to the given wrapper class. e.g. "boolean" for "Boolean", "char" for "Character" etc...

Parameters

elementClassName:String: the type of the array element ("Boolean", "Character", etc...)

Returns:String

the primitive type name corresponding to the given wrapper class ("boolean", "char", etc...) return null if the given elementClassName is not a primitive wrapper type name.

hashCode back to summary

hashCode	back to summary
public int hashCode() Implements abstract javax.management.openmbean.OpenType.hashCode. Returns the hash code value for this `ArrayType` instance. The hash code of an `ArrayType` instance is the sum of the hash codes of all the elements of information used in `equals` comparisons (i.e. dimension, elements' open type and primitive array flag). The hashcode for a primitive value is the hashcode of the corresponding boxed object (e.g. the hashcode for `true` is `Boolean.TRUE.hashCode()`). This ensures that `t1.equals(t2)` implies that `t1.hashCode()==t2.hashCode()` for any two `ArrayType` instances `t1` and `t2`, as required by the general contract of the method `Object.hashCode()`. As `ArrayType` instances are immutable, the hash code for this instance is calculated once, on the first call to `hashCode`, and then the same value is returned for subsequent calls. Returns:int the hash code value for this `ArrayType` instance

public int hashCode()

Implements abstract javax.management.openmbean.OpenType.hashCode.

Returns the hash code value for this ArrayType instance.

The hash code of an ArrayType instance is the sum of the hash codes of all the elements of information used in equals comparisons (i.e. dimension, elements' open type and primitive array flag). The hashcode for a primitive value is the hashcode of the corresponding boxed object (e.g. the hashcode for true is Boolean.TRUE.hashCode()). This ensures that t1.equals(t2) implies that t1.hashCode()==t2.hashCode() for any two ArrayType instances t1 and t2, as required by the general contract of the method Object.hashCode().

As ArrayType instances are immutable, the hash code for this instance is calculated once, on the first call to hashCode, and then the same value is returned for subsequent calls.

Returns:int: the hash code value for this ArrayType instance

isAssignableFrom back to summary

isAssignableFrom	back to summary
pack-priv boolean isAssignableFrom(OpenType<?> ot) Overrides javax.management.openmbean.OpenType.isAssignableFrom. Doc from javax.management.openmbean.OpenType.isAssignableFrom. Tests whether values of the given type can be assigned to this open type. The default implementation of this method returns true only if the types are equal. Parameters ot:OpenType<?> the type to be tested. Returns:boolean true if `ot` is assignable to this open type. Annotations @Override

pack-priv boolean isAssignableFrom(OpenType<?> ot)

Overrides javax.management.openmbean.OpenType.isAssignableFrom.

Doc from javax.management.openmbean.OpenType.isAssignableFrom.

Tests whether values of the given type can be assigned to this open type. The default implementation of this method returns true only if the types are equal.

Parameters

ot:OpenType<?>: the type to be tested.

Returns:boolean

true if ot is assignable to this open type.

Annotations

@Override

isPrimitiveArray back to summary

isPrimitiveArray	back to summary
public boolean isPrimitiveArray() Returns `true` if the open data values this open type describes are primitive arrays, `false` otherwise. Returns:boolean true if this is a primitive array type. Since 1.6

public boolean isPrimitiveArray()

Returns true if the open data values this open type describes are primitive arrays, false otherwise.

Returns:boolean: true if this is a primitive array type.
Since: 1.6

isPrimitiveContentType	back to summary
pack-priv static boolean isPrimitiveContentType(final String primitiveKey)

isValue back to summary

isValue	back to summary
public boolean isValue(Object obj) Implements abstract javax.management.openmbean.OpenType.isValue. Tests whether `obj` is a value for this `ArrayType` instance. This method returns `true` if and only if `obj` is not null, `obj` is an array and any one of the following is `true`: if this `ArrayType` instance describes an array of `SimpleType` elements or their corresponding primitive types, `obj`'s class name is the same as the className field defined for this `ArrayType` instance (i.e. the class name returned by the `getClassName` method, which includes the dimension information), if this `ArrayType` instance describes an array of classes implementing the `TabularData` interface or the `CompositeData` interface, `obj` is assignable to such a declared array, and each element contained in {`obj` is either null or a valid value for the element's open type specified by this `ArrayType` instance. Parameters obj:Object the object to be tested. Returns:boolean `true` if `obj` is a value for this `ArrayType` instance.

public boolean isValue(Object obj)

Implements abstract javax.management.openmbean.OpenType.isValue.

Tests whether obj is a value for this ArrayType instance.

This method returns true if and only if obj is not null, obj is an array and any one of the following is true:

if this ArrayType instance describes an array of SimpleType elements or their corresponding primitive types, obj's class name is the same as the className field defined for this ArrayType instance (i.e. the class name returned by the getClassName method, which includes the dimension information),
if this ArrayType instance describes an array of classes implementing the TabularData interface or the CompositeData interface, obj is assignable to such a declared array, and each element contained in {obj is either null or a valid value for the element's open type specified by this ArrayType instance.

Parameters

obj:Object: the object to be tested.

Returns:boolean

true if obj is a value for this ArrayType instance.

readResolve back to summary

readResolve	back to summary
private Object readResolve() throws ObjectStreamException Replace/resolve the object read from the stream before it is returned to the caller. Since 1.6 Serial data The new serial form of this class defines a new serializable `boolean` field `primitiveArray`. In order to guarantee the interoperability with previous versions of this class the new serial form must continue to refer to primitive wrapper types even when the `ArrayType` instance describes a primitive type array. So when `primitiveArray` is `true` the `className`, `typeName` and `description` serializable fields are converted into primitive types before the deserialized `ArrayType` instance is return to the caller. The `elementType` field always returns the `SimpleType` corresponding to the primitive wrapper type of the array's primitive type. Therefore the following serializable fields are deserialized as follows: if `primitiveArray` is `true` the `className` field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. `"[[Ljava.lang.Integer;"` will be deserialized as `"[[I"`. if `primitiveArray` is `true` the `typeName` field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. `"[[Ljava.lang.Integer;"` will be deserialized as `"[[I"`. if `primitiveArray` is `true` the `description` field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. `"2-dimension array of java.lang.Integer"` will be deserialized as `"2-dimension array of int"`.

private Object readResolve() throws ObjectStreamException

Replace/resolve the object read from the stream before it is returned to the caller.

Since

1.6

Serial data

The new serial form of this class defines a new serializable boolean field primitiveArray. In order to guarantee the interoperability with previous versions of this class the new serial form must continue to refer to primitive wrapper types even when the ArrayType instance describes a primitive type array. So when primitiveArray is true the className, typeName and description serializable fields are converted into primitive types before the deserialized ArrayType instance is return to the caller. The elementType field always returns the SimpleType corresponding to the primitive wrapper type of the array's primitive type.

Therefore the following serializable fields are deserialized as follows:

if primitiveArray is true the className field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. "[[Ljava.lang.Integer;" will be deserialized as "[[I".
if primitiveArray is true the typeName field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. "[[Ljava.lang.Integer;" will be deserialized as "[[I".
if primitiveArray is true the description field is deserialized by replacing the array's component primitive wrapper type by the corresponding array's component primitive type, e.g. "2-dimension array of java.lang.Integer" will be deserialized as "2-dimension array of int".

toString back to summary

toString	back to summary
public String toString() Implements abstract javax.management.openmbean.OpenType.toString. Returns a string representation of this `ArrayType` instance. The string representation consists of the name of this class (i.e. `javax.management.openmbean.ArrayType`), the type name, the dimension, the elements' open type and the primitive array flag defined for this instance. As `ArrayType` instances are immutable, the string representation for this instance is calculated once, on the first call to `toString`, and then the same value is returned for subsequent calls. Returns:String a string representation of this `ArrayType` instance

public String toString()

Implements abstract javax.management.openmbean.OpenType.toString.

Returns a string representation of this ArrayType instance.

The string representation consists of the name of this class (i.e. javax.management.openmbean.ArrayType), the type name, the dimension, the elements' open type and the primitive array flag defined for this instance.

As ArrayType instances are immutable, the string representation for this instance is calculated once, on the first call to toString, and then the same value is returned for subsequent calls.

Returns:String: a string representation of this ArrayType instance

writeReplace back to summary

writeReplace	back to summary
private Object writeReplace() throws ObjectStreamException Nominate a replacement for this object in the stream before the object is written. Since 1.6 Serial data The new serial form of this class defines a new serializable `boolean` field `primitiveArray`. In order to guarantee the interoperability with previous versions of this class the new serial form must continue to refer to primitive wrapper types even when the `ArrayType` instance describes a primitive type array. So when `primitiveArray` is `true` the `className`, `typeName` and `description` serializable fields are converted into wrapper types before the serialized `ArrayType` instance is written to the stream. The `elementType` field always returns the `SimpleType` corresponding to the primitive wrapper type of the array's primitive type. Therefore the following serializable fields are serialized as follows: if `primitiveArray` is `true` the `className` field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. `"[[I"` will be serialized as `"[[Ljava.lang.Integer;"`. if `primitiveArray` is `true` the `typeName` field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. `"[[I"` will be serialized as `"[[Ljava.lang.Integer;"`. if `primitiveArray` is `true` the `description` field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. `"2-dimension array of int"` will be serialized as `"2-dimension array of java.lang.Integer"`.

private Object writeReplace() throws ObjectStreamException

Nominate a replacement for this object in the stream before the object is written.

Since

1.6

Serial data

The new serial form of this class defines a new serializable boolean field primitiveArray. In order to guarantee the interoperability with previous versions of this class the new serial form must continue to refer to primitive wrapper types even when the ArrayType instance describes a primitive type array. So when primitiveArray is true the className, typeName and description serializable fields are converted into wrapper types before the serialized ArrayType instance is written to the stream. The elementType field always returns the SimpleType corresponding to the primitive wrapper type of the array's primitive type.

Therefore the following serializable fields are serialized as follows:

if primitiveArray is true the className field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. "[[I" will be serialized as "[[Ljava.lang.Integer;".
if primitiveArray is true the typeName field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. "[[I" will be serialized as "[[Ljava.lang.Integer;".
if primitiveArray is true the description field is serialized by replacing the array's component primitive type by the corresponding array's component primitive wrapper type, e.g. "2-dimension array of int" will be serialized as "2-dimension array of java.lang.Integer".

public Class ArrayType<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail