Top Description Fields Constructors Methods
javax.management.openmbean

public Class ArrayType<T>

extends OpenType<T>
Class Inheritance
Type Parameters
<T>
the Java component type that arrays described by this ArrayType must have.
Imports
java.io.ObjectStreamException, java.lang.reflect.Array

The ArrayType class is the open type class whose instances describe all open data values which are n-dimensional arrays of open data values.

Examples of valid ArrayType instances are:

// 2-dimension array of java.lang.String
ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);

// 1-dimension array of int
ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);

// 1-dimension array of java.lang.Integer
ArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false);

// 4-dimension array of int
ArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2);

// 4-dimension array of java.lang.Integer
ArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3);

// 1-dimension array of java.lang.String
ArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false);

// 1-dimension array of long
ArrayType<long[]> a7 = new ArrayType<long[]>(SimpleType.LONG, true);

// 1-dimension array of java.lang.Integer
ArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER);

// 2-dimension array of java.lang.Integer
ArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8);

// 2-dimension array of int
ArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class);

// 3-dimension array of int
ArrayType<int[][][]> a11 = ArrayType.getArrayType(a10);

// 1-dimension array of float
ArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class);

// 2-dimension array of float
ArrayType<float[][]> a13 = ArrayType.getArrayType(a12);

// 1-dimension array of javax.management.ObjectName
ArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME);

// 2-dimension array of javax.management.ObjectName
ArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14);

// 3-dimension array of java.lang.String
ArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING);

// 1-dimension array of java.lang.String
ArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING);

// 2-dimension array of java.lang.String
ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);

// 3-dimension array of java.lang.String
ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
Since
1.5

Field Summary

Modifier and TypeField and Description
private int
private OpenType<?>
private transient Integer
private transient String
private static final Object[][]
private static final int
private static final int
private static final int
private static final int
private boolean
pack-priv static final long
Inherited from javax.management.openmbean.OpenType:
ALLOWED_CLASSNAMESALLOWED_CLASSNAMES_LIST

Constructor Summary

AccessConstructor 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 TypeMethod 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>
private <T> ArrayType<T>
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:
getClassNamegetDescriptiongetDescriptorgetTypeNameisArraysafeGetClassName

Field Detail

dimensionback to summary
private int dimension
elementTypeback to summary
private OpenType<?> elementType
myHashCodeback to summary
private transient Integer myHashCode
myToStringback to summary
private transient String myToString
PRIMITIVE_ARRAY_TYPESback to summary
private static final Object[][] PRIMITIVE_ARRAY_TYPES
PRIMITIVE_OPEN_TYPE_INDEXback to summary
private static final int PRIMITIVE_OPEN_TYPE_INDEX
PRIMITIVE_TYPE_KEY_INDEXback to summary
private static final int PRIMITIVE_TYPE_KEY_INDEX
PRIMITIVE_TYPE_NAME_INDEXback to summary
private static final int PRIMITIVE_TYPE_NAME_INDEX
PRIMITIVE_WRAPPER_NAME_INDEXback to summary
private static final int PRIMITIVE_WRAPPER_NAME_INDEX
primitiveArrayback to summary
private boolean primitiveArray
Since
1.6
serialVersionUIDback to summary
pack-priv static final long serialVersionUID

Hides javax.management.openmbean.OpenType.serialVersionUID.

Constructor Detail

ArrayTypeback 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.
ArrayTypeback 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
ArrayTypeback to summary
pack-priv ArrayType(String className, String typeName, String description, int dimension, OpenType<?> elementType, boolean primitiveArray)

Method Detail

buildArrayClassNameback to summary
private static String buildArrayClassName(int dimension, OpenType<?> elementType) throws OpenDataException
buildArrayClassNameback to summary
private static String buildArrayClassName(int dimension, OpenType<?> elementType, boolean isPrimitiveArray) throws OpenDataException
buildArrayDescriptionback to summary
private static String buildArrayDescription(int dimension, OpenType<?> elementType) throws OpenDataException
buildArrayDescriptionback to summary
private static String buildArrayDescription(int dimension, OpenType<?> elementType, boolean isPrimitiveArray) throws OpenDataException
checkElementsTypeback 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.

convertFromPrimitiveToWrapperTypesback to summary
private <T> ArrayType<T> convertFromPrimitiveToWrapperTypes()
convertFromWrapperToPrimitiveTypesback to summary
private <T> ArrayType<T> convertFromWrapperToPrimitiveTypes()
equalsback 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.

getArrayTypeback 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
getDimensionback to summary
public int getDimension()

Returns the dimension of arrays described by this ArrayType instance.

Returns:int

the dimension.

getElementOpenTypeback 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.

getPrimitiveArrayTypeback 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
getPrimitiveOpenTypeback 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.

getPrimitiveTypeKeyback 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.

getPrimitiveTypeNameback 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.

hashCodeback 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

isAssignableFromback 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
isPrimitiveArrayback 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
isPrimitiveContentTypeback to summary
pack-priv static boolean isPrimitiveContentType(final String primitiveKey)
isValueback 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.

readResolveback 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".
toStringback 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

writeReplaceback 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".