Back to index...

	/*
	* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.management.openmbean;

	import java.io.ObjectStreamException;
	import java.lang.reflect.Array;

	/**
	* The <code>ArrayType</code> class is the <i>open type</i> class whose instances describe
	* all <i>open data</i> values which are n-dimensional arrays of <i>open data</i> values.
	* <p>
	* Examples of valid {@code ArrayType} instances are:
	* <pre>{@code
	* // 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);
	* }</pre>
	*
	*
	* @since 1.5
	*/
	/*
	Generification note: we could have defined a type parameter that is the
	element type, with class ArrayType<E> extends OpenType<E[]>. However,
	that doesn't buy us all that much. We can't say
	public OpenType<E> getElementOpenType()
	because this ArrayType could be a multi-dimensional array.
	For example, if we had
	ArrayType(2, SimpleType.INTEGER)
	then E would have to be Integer[], while getElementOpenType() would
	return SimpleType.INTEGER, which is an OpenType<Integer>.

	Furthermore, we would like to support int[] (as well as Integer[]) as
	an Open Type (RFE 5045358). We would want this to be an OpenType<int[]>
	which can't be expressed as <E[]> because E can't be a primitive type
	like int.
	*/
	public class ArrayType<T> extends OpenType<T> {

	/* Serial version */
	static final long serialVersionUID = 720504429830309770L;

	/**
	* @serial The dimension of arrays described by this {@link ArrayType}
	* instance.
	*/
	private int dimension;

	/**
	* @serial The <i>open type</i> of element values contained in the arrays
	* described by this {@link ArrayType} instance.
	*/
	private OpenType<?> elementType;

	/**
	* @serial This flag indicates whether this {@link ArrayType}
	* describes a primitive array.
	*
	* @since 1.6
	*/
	private boolean primitiveArray;

	private transient Integer myHashCode = null; // As this instance is immutable, these two values
	private transient String myToString = null; // need only be calculated once.

	// indexes refering to columns in the PRIMITIVE_ARRAY_TYPES table.
	private static final int PRIMITIVE_WRAPPER_NAME_INDEX = 0;
	private static final int PRIMITIVE_TYPE_NAME_INDEX = 1;
	private static final int PRIMITIVE_TYPE_KEY_INDEX = 2;
	private static final int PRIMITIVE_OPEN_TYPE_INDEX = 3;

	private static final Object[][] PRIMITIVE_ARRAY_TYPES = {
	{ Boolean.class.getName(), boolean.class.getName(), "Z", SimpleType.BOOLEAN },
	{ Character.class.getName(), char.class.getName(), "C", SimpleType.CHARACTER },
	{ Byte.class.getName(), byte.class.getName(), "B", SimpleType.BYTE },
	{ Short.class.getName(), short.class.getName(), "S", SimpleType.SHORT },
	{ Integer.class.getName(), int.class.getName(), "I", SimpleType.INTEGER },
	{ Long.class.getName(), long.class.getName(), "J", SimpleType.LONG },
	{ Float.class.getName(), float.class.getName(), "F", SimpleType.FLOAT },
	{ Double.class.getName(), double.class.getName(), "D", SimpleType.DOUBLE }
	};

	static boolean isPrimitiveContentType(final String primitiveKey) {
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (typeDescr[PRIMITIVE_TYPE_KEY_INDEX].equals(primitiveKey)) {
	return true;
	}
	}
	return false;
	}

	/**
	* Return the key used to identify the element type in
	* arrays - e.g. "Z" for boolean, "C" for char etc...
	* @param elementClassName the wrapper class name of the array
	* element ("Boolean", "Character", etc...)
	* @return the key corresponding to the given type ("Z", "C", etc...)
	* return null if the given elementClassName is not a primitive
	* wrapper class name.
	**/
	static String getPrimitiveTypeKey(String elementClassName) {
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (elementClassName.equals(typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]))
	return (String)typeDescr[PRIMITIVE_TYPE_KEY_INDEX];
	}
	return null;
	}

	/**
	* Return the primitive type name corresponding to the given wrapper class.
	* e.g. "boolean" for "Boolean", "char" for "Character" etc...
	* @param elementClassName the type of the array element ("Boolean",
	* "Character", etc...)
	* @return 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.
	**/
	static String getPrimitiveTypeName(String elementClassName) {
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (elementClassName.equals(typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]))
	return (String)typeDescr[PRIMITIVE_TYPE_NAME_INDEX];
	}
	return null;
	}

	/**
	* Return the primitive open type corresponding to the given primitive type.
	* e.g. SimpleType.BOOLEAN for "boolean", SimpleType.CHARACTER for
	* "char", etc...
	* @param primitiveTypeName the primitive type of the array element ("boolean",
	* "char", etc...)
	* @return 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.
	**/
	static SimpleType<?> getPrimitiveOpenType(String primitiveTypeName) {
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (primitiveTypeName.equals(typeDescr[PRIMITIVE_TYPE_NAME_INDEX]))
	return (SimpleType<?>)typeDescr[PRIMITIVE_OPEN_TYPE_INDEX];
	}
	return null;
	}

	/* * Constructor * */

	/**
	* Constructs an <tt>ArrayType</tt> instance describing <i>open data</i> values which are
	* arrays with dimension <var>dimension</var> of elements whose <i>open type</i> is <var>elementType</var>.
	* <p>
	* When invoked on an <tt>ArrayType</tt> instance, the {@link OpenType#getClassName() getClassName} method
	* returns the class name of the array instances it describes (following the rules defined by the
	* {@link Class#getName() getName} method of <code>java.lang.Class</code>), not the class name of the array elements
	* (which is returned by a call to <tt>getElementOpenType().getClassName()</tt>).
	* <p>
	* The internal field corresponding to the type name of this <code>ArrayType</code> instance is also set to
	* the class name of the array instances it describes.
	* In other words, the methods <code>getClassName</code> and <code>getTypeName</code> return the same string value.
	* The internal field corresponding to the description of this <code>ArrayType</code> instance is set to a string value
	* which follows the following template:
	* <ul>
	* <li>if non-primitive array: <tt><i><dimension></i>-dimension array of <i><element_class_name></i></tt></li>
	* <li>if primitive array: <tt><i><dimension></i>-dimension array of <i><primitive_type_of_the_element_class_name></i></tt></li>
	* </ul>
	* <p>
	* As an example, the following piece of code:
	* <pre>{@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());
	* }</pre>
	* would produce the following output:
	* <pre>{@code
	* 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
	* }</pre>
	* And the following piece of code which is equivalent to the one listed
	* above would also produce the same output:
	* <pre>{@code
	* 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());
	* }</pre>
	*
	* @param dimension the dimension of arrays described by this <tt>ArrayType</tt> instance;
	* must be greater than or equal to 1.
	*
	* @param elementType the <i>open type</i> of element values contained
	* in the arrays described by this <tt>ArrayType</tt>
	* instance; must be an instance of either
	* <tt>SimpleType</tt>, <tt>CompositeType</tt>,
	* <tt>TabularType</tt> or another <tt>ArrayType</tt>
	* with a <tt>SimpleType</tt>, <tt>CompositeType</tt>
	* or <tt>TabularType</tt> as its <tt>elementType</tt>.
	*
	* @throws IllegalArgumentException if {@code dimension} is not a positive
	* integer.
	* @throws OpenDataException if <var>elementType's className</var> is not
	* one of the allowed Java class names for open
	* data.
	*/
	public ArrayType(int dimension,
	OpenType<?> elementType) throws OpenDataException {
	// Check and construct state defined by parent.
	// We can't use the package-private OpenType constructor because
	// we don't know if the elementType parameter is sane.
	super(buildArrayClassName(dimension, elementType),
	buildArrayClassName(dimension, elementType),
	buildArrayDescription(dimension, elementType));

	// Check and construct state specific to ArrayType
	//
	if (elementType.isArray()) {
	ArrayType<?> at = (ArrayType<?>) elementType;
	this.dimension = at.getDimension() + dimension;
	this.elementType = at.getElementOpenType();
	this.primitiveArray = at.isPrimitiveArray();
	} else {
	this.dimension = dimension;
	this.elementType = elementType;
	this.primitiveArray = false;
	}
	}

	/**
	* Constructs a unidimensional {@code ArrayType} instance for the
	* supplied {@code SimpleType}.
	* <p>
	* This constructor supports the creation of arrays of primitive
	* types when {@code primitiveArray} is {@code true}.
	* <p>
	* For primitive arrays the {@link #getElementOpenType()} method
	* returns the {@link SimpleType} corresponding to the wrapper
	* type of the primitive type of the array.
	* <p>
	* When invoked on an <tt>ArrayType</tt> instance, the {@link OpenType#getClassName() getClassName} method
	* returns the class name of the array instances it describes (following the rules defined by the
	* {@link Class#getName() getName} method of <code>java.lang.Class</code>), not the class name of the array elements
	* (which is returned by a call to <tt>getElementOpenType().getClassName()</tt>).
	* <p>
	* The internal field corresponding to the type name of this <code>ArrayType</code> instance is also set to
	* the class name of the array instances it describes.
	* In other words, the methods <code>getClassName</code> and <code>getTypeName</code> return the same string value.
	* The internal field corresponding to the description of this <code>ArrayType</code> instance is set to a string value
	* which follows the following template:
	* <ul>
	* <li>if non-primitive array: <tt>1-dimension array of <i><element_class_name></i></tt></li>
	* <li>if primitive array: <tt>1-dimension array of <i><primitive_type_of_the_element_class_name></i></tt></li>
	* </ul>
	* <p>
	* As an example, the following piece of code:
	* <pre>{@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());
	* }</pre>
	* would produce the following output:
	* <pre>{@code
	* array class name = [I
	* element class name = java.lang.Integer
	* array type name = [I
	* array type description = 1-dimension array of int
	* }</pre>
	*
	* @param elementType the {@code SimpleType} of the element values
	* contained in the arrays described by this
	* {@code ArrayType} instance.
	*
	* @param primitiveArray {@code true} when this array describes
	* primitive arrays.
	*
	* @throws IllegalArgumentException if {@code dimension} is not a positive
	* integer.
	* @throws OpenDataException if {@code primitiveArray} is {@code true} and
	* {@code elementType} is not a valid {@code SimpleType} for a primitive
	* type.
	*
	* @since 1.6
	*/
	public ArrayType(SimpleType<?> elementType,
	boolean primitiveArray) throws OpenDataException {

	// Check and construct state defined by parent.
	// We can call the package-private OpenType constructor because the
	// set of SimpleTypes is fixed and SimpleType can't be subclassed.
	super(buildArrayClassName(1, elementType, primitiveArray),
	buildArrayClassName(1, elementType, primitiveArray),
	buildArrayDescription(1, elementType, primitiveArray),
	true);

	// Check and construct state specific to ArrayType
	//
	this.dimension = 1;
	this.elementType = elementType;
	this.primitiveArray = primitiveArray;
	}

	/* Package-private constructor for callers we trust to get it right. */
	ArrayType(String className, String typeName, String description,
	int dimension, OpenType<?> elementType,
	boolean primitiveArray) {
	super(className, typeName, description, true);
	this.dimension = dimension;
	this.elementType = elementType;
	this.primitiveArray = primitiveArray;
	}

	private static String buildArrayClassName(int dimension,
	OpenType<?> elementType)
	throws OpenDataException {
	boolean isPrimitiveArray = false;
	if (elementType.isArray()) {
	isPrimitiveArray = ((ArrayType<?>) elementType).isPrimitiveArray();
	}
	return buildArrayClassName(dimension, elementType, isPrimitiveArray);
	}

	private static String buildArrayClassName(int dimension,
	OpenType<?> elementType,
	boolean isPrimitiveArray)
	throws OpenDataException {
	if (dimension < 1) {
	throw new IllegalArgumentException(
	"Value of argument dimension must be greater than 0");
	}
	StringBuilder result = new StringBuilder();
	String elementClassName = elementType.getClassName();
	// Add N (= dimension) additional '[' characters to the existing array
	for (int i = 1; i <= dimension; i++) {
	result.append('[');
	}
	if (elementType.isArray()) {
	result.append(elementClassName);
	} else {
	if (isPrimitiveArray) {
	final String key = getPrimitiveTypeKey(elementClassName);
	// Ideally we should throw an IllegalArgumentException here,
	// but for compatibility reasons we throw an OpenDataException.
	// (used to be thrown by OpenType() constructor).
	//
	if (key == null)
	throw new OpenDataException("Element type is not primitive: "
	+ elementClassName);
	result.append(key);
	} else {
	result.append("L");
	result.append(elementClassName);
	result.append(';');
	}
	}
	return result.toString();
	}

	private static String buildArrayDescription(int dimension,
	OpenType<?> elementType)
	throws OpenDataException {
	boolean isPrimitiveArray = false;
	if (elementType.isArray()) {
	isPrimitiveArray = ((ArrayType<?>) elementType).isPrimitiveArray();
	}
	return buildArrayDescription(dimension, elementType, isPrimitiveArray);
	}

	private static String buildArrayDescription(int dimension,
	OpenType<?> elementType,
	boolean isPrimitiveArray)
	throws OpenDataException {
	if (elementType.isArray()) {
	ArrayType<?> at = (ArrayType<?>) elementType;
	dimension += at.getDimension();
	elementType = at.getElementOpenType();
	isPrimitiveArray = at.isPrimitiveArray();
	}
	StringBuilder result =
	new StringBuilder(dimension + "-dimension array of ");
	final String elementClassName = elementType.getClassName();
	if (isPrimitiveArray) {
	// Convert from wrapper type to primitive type
	final String primitiveType =
	getPrimitiveTypeName(elementClassName);

	// Ideally we should throw an IllegalArgumentException here,
	// but for compatibility reasons we throw an OpenDataException.
	// (used to be thrown by OpenType() constructor).
	//
	if (primitiveType == null)
	throw new OpenDataException("Element is not a primitive type: "+
	elementClassName);
	result.append(primitiveType);
	} else {
	result.append(elementClassName);
	}
	return result.toString();
	}

	/* * ArrayType specific information methods * */

	/**
	* Returns the dimension of arrays described by this <tt>ArrayType</tt> instance.
	*
	* @return the dimension.
	*/
	public int getDimension() {

	return dimension;
	}

	/**
	* Returns the <i>open type</i> of element values contained in the arrays described by this <tt>ArrayType</tt> instance.
	*
	* @return the element type.
	*/
	public OpenType<?> getElementOpenType() {

	return elementType;
	}

	/**
	* Returns <code>true</code> if the open data values this open
	* type describes are primitive arrays, <code>false</code> otherwise.
	*
	* @return true if this is a primitive array type.
	*
	* @since 1.6
	*/
	public boolean isPrimitiveArray() {

	return primitiveArray;
	}

	/**
	* Tests whether <var>obj</var> is a value for this <code>ArrayType</code>
	* instance.
	* <p>
	* This method returns <code>true</code> if and only if <var>obj</var>
	* is not null, <var>obj</var> is an array and any one of the following
	* is <tt>true</tt>:
	*
	* <ul>
	* <li>if this <code>ArrayType</code> instance describes an array of
	* <tt>SimpleType</tt> elements or their corresponding primitive types,
	* <var>obj</var>'s class name is the same as the className field defined
	* for this <code>ArrayType</code> instance (i.e. the class name returned
	* by the {@link OpenType#getClassName() getClassName} method, which
	* includes the dimension information),<br> </li>
	* <li>if this <code>ArrayType</code> instance describes an array of
	* classes implementing the {@code TabularData} interface or the
	* {@code CompositeData} interface, <var>obj</var> is assignable to
	* such a declared array, and each element contained in {<var>obj</var>
	* is either null or a valid value for the element's open type specified
	* by this <code>ArrayType</code> instance.</li>
	* </ul>
	*
	* @param obj the object to be tested.
	*
	* @return <code>true</code> if <var>obj</var> is a value for this
	* <code>ArrayType</code> instance.
	*/
	public boolean isValue(Object obj) {

	// if obj is null, return false
	//
	if (obj == null) {
	return false;
	}

	Class<?> objClass = obj.getClass();
	String objClassName = objClass.getName();

	// if obj is not an array, return false
	//
	if ( ! objClass.isArray() ) {
	return false;
	}

	// Test if obj's class name is the same as for the array values that this instance describes
	// (this is fine if elements are of simple types, which are final classes)
	//
	if ( this.getClassName().equals(objClassName) ) {
	return true;
	}

	// In case this ArrayType instance describes an array of classes implementing the TabularData or CompositeData interface,
	// we first check for the assignability of obj to such an array of TabularData or CompositeData,
	// which ensures that:
	// . obj is of the the same dimension as this ArrayType instance,
	// . it is declared as an array of elements which are either all TabularData or all CompositeData.
	//
	// If the assignment check is positive,
	// then we have to check that each element in obj is of the same TabularType or CompositeType
	// as the one described by this ArrayType instance.
	//
	// [About assignment check, note that the call below returns true: ]
	// [Class.forName("[Lpackage.CompositeData;").isAssignableFrom(Class.forName("[Lpackage.CompositeDataImpl;)")); ]
	//
	if ( (this.elementType.getClassName().equals(TabularData.class.getName())) \|\|
	(this.elementType.getClassName().equals(CompositeData.class.getName())) ) {

	boolean isTabular =
	(elementType.getClassName().equals(TabularData.class.getName()));
	int[] dims = new int[getDimension()];
	Class<?> elementClass = isTabular ? TabularData.class : CompositeData.class;
	Class<?> targetClass = Array.newInstance(elementClass, dims).getClass();

	// assignment check: return false if negative
	if ( ! targetClass.isAssignableFrom(objClass) ) {
	return false;
	}

	// check that all elements in obj are valid values for this ArrayType
	if ( ! checkElementsType( (Object[]) obj, this.dimension) ) { // we know obj's dimension is this.dimension
	return false;
	}

	return true;
	}

	// if previous tests did not return, then obj is not a value for this ArrayType instance
	return false;
	}

	/**
	* 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.
	*/
	private boolean checkElementsType(Object[] x_dim_Array, int dim) {

	// if the elements of x_dim_Array are themselves array: go down recursively....
	if ( dim > 1 ) {
	for (int i=0; i<x_dim_Array.length; i++) {
	if ( ! checkElementsType((Object[])x_dim_Array[i], dim-1) ) {
	return false;
	}
	}
	return true;
	}
	// ...else, for a non-empty array, each element must be a valid value: either null or of the right openType
	else {
	for (int i=0; i<x_dim_Array.length; i++) {
	if ( (x_dim_Array[i] != null) && (! this.getElementOpenType().isValue(x_dim_Array[i])) ) {
	return false;
	}
	}
	return true;
	}
	}

	@Override
	boolean isAssignableFrom(OpenType<?> ot) {
	if (!(ot instanceof ArrayType<?>))
	return false;
	ArrayType<?> at = (ArrayType<?>) ot;
	return (at.getDimension() == getDimension() &&
	at.isPrimitiveArray() == isPrimitiveArray() &&
	at.getElementOpenType().isAssignableFrom(getElementOpenType()));
	}


	/* * Methods overriden from class Object * */

	/**
	* Compares the specified <code>obj</code> parameter with this
	* <code>ArrayType</code> instance for equality.
	* <p>
	* Two <code>ArrayType</code> instances are equal if and only if they
	* describe array instances which have the same dimension, elements'
	* open type and primitive array flag.
	*
	* @param obj the object to be compared for equality with this
	* <code>ArrayType</code> instance; if <var>obj</var>
	* is <code>null</code> or is not an instance of the
	* class <code>ArrayType</code> this method returns
	* <code>false</code>.
	*
	* @return <code>true</code> if the specified object is equal to
	* this <code>ArrayType</code> instance.
	*/
	public boolean equals(Object obj) {

	// if obj is null, return false
	//
	if (obj == null) {
	return false;
	}

	// if obj is not an ArrayType, return false
	//
	if (!(obj instanceof ArrayType<?>))
	return false;
	ArrayType<?> other = (ArrayType<?>) obj;

	// if other's dimension is different than this instance's, return false
	//
	if (this.dimension != other.dimension) {
	return false;
	}

	// Test if other's elementType field is the same as for this instance
	//
	if (!this.elementType.equals(other.elementType)) {
	return false;
	}

	// Test if other's primitiveArray flag is the same as for this instance
	//
	return this.primitiveArray == other.primitiveArray;
	}

	/**
	* Returns the hash code value for this <code>ArrayType</code> instance.
	* <p>
	* The hash code of an <code>ArrayType</code> instance is the sum of the
	* hash codes of all the elements of information used in <code>equals</code>
	* 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 <tt>true</tt> is <tt>Boolean.TRUE.hashCode()</tt>).
	* This ensures that <code> t1.equals(t2) </code> implies that
	* <code> t1.hashCode()==t2.hashCode() </code> for any two
	* <code>ArrayType</code> instances <code>t1</code> and <code>t2</code>,
	* as required by the general contract of the method
	* {@link Object#hashCode() Object.hashCode()}.
	* <p>
	* As <code>ArrayType</code> instances are immutable, the hash
	* code for this instance is calculated once, on the first call
	* to <code>hashCode</code>, and then the same value is returned
	* for subsequent calls.
	*
	* @return the hash code value for this <code>ArrayType</code> instance
	*/
	public int hashCode() {

	// Calculate the hash code value if it has not yet been done (ie 1st call to hashCode())
	//
	if (myHashCode == null) {
	int value = 0;
	value += dimension;
	value += elementType.hashCode();
	value += Boolean.valueOf(primitiveArray).hashCode();
	myHashCode = Integer.valueOf(value);
	}

	// return always the same hash code for this instance (immutable)
	//
	return myHashCode.intValue();
	}

	/**
	* Returns a string representation of this <code>ArrayType</code> instance.
	* <p>
	* The string representation consists of the name of this class (i.e.
	* <code>javax.management.openmbean.ArrayType</code>), the type name,
	* the dimension, the elements' open type and the primitive array flag
	* defined for this instance.
	* <p>
	* As <code>ArrayType</code> instances are immutable, the
	* string representation for this instance is calculated
	* once, on the first call to <code>toString</code>, and
	* then the same value is returned for subsequent calls.
	*
	* @return a string representation of this <code>ArrayType</code> instance
	*/
	public String toString() {

	// Calculate the string representation if it has not yet been done (ie 1st call to toString())
	//
	if (myToString == null) {
	myToString = getClass().getName() +
	"(name=" + getTypeName() +
	",dimension=" + dimension +
	",elementType=" + elementType +
	",primitiveArray=" + primitiveArray + ")";
	}

	// return always the same string representation for this instance (immutable)
	//
	return myToString;
	}

	/**
	* Create an {@code ArrayType} instance in a type-safe manner.
	* <p>
	* Multidimensional arrays can be built up by calling this method as many
	* times as necessary.
	* <p>
	* Calling this method twice with the same parameters may return the same
	* object or two equal but not identical objects.
	* <p>
	* As an example, the following piece of code:
	* <pre>{@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());
	* }</pre>
	* would produce the following output:
	* <pre>{@code
	* 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
	* }</pre>
	*
	* @param elementType the <i>open type</i> of element values contained
	* in the arrays described by this <tt>ArrayType</tt>
	* instance; must be an instance of either
	* <tt>SimpleType</tt>, <tt>CompositeType</tt>,
	* <tt>TabularType</tt> or another <tt>ArrayType</tt>
	* with a <tt>SimpleType</tt>, <tt>CompositeType</tt>
	* or <tt>TabularType</tt> as its <tt>elementType</tt>.
	*
	* @throws OpenDataException if <var>elementType's className</var> 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 {
	return new ArrayType<E[]>(1, elementType);
	}

	/**
	* Create an {@code ArrayType} instance in a type-safe manner.
	* <p>
	* Calling this method twice with the same parameters may return the
	* same object or two equal but not identical objects.
	* <p>
	* As an example, the following piece of code:
	* <pre>{@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());
	* }</pre>
	* would produce the following output:
	* <pre>{@code
	* array class name = [[[I
	* element class name = java.lang.Integer
	* array type name = [[[I
	* array type description = 3-dimension array of int
	* }</pre>
	*
	* @param arrayClass a primitive array class such as {@code int[].class},
	* {@code boolean[][].class}, etc. The {@link
	* #getElementOpenType()} method of the returned
	* {@code ArrayType} returns the {@link SimpleType}
	* corresponding to the wrapper type of the primitive
	* type of the array.
	*
	* @throws IllegalArgumentException if <var>arrayClass</var> is not
	* a primitive array.
	*
	* @since 1.6
	*/
	@SuppressWarnings("unchecked") // can't get appropriate T for primitive array
	public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> arrayClass) {
	// Check if the supplied parameter is an array
	//
	if (!arrayClass.isArray()) {
	throw new IllegalArgumentException("arrayClass must be an array");
	}

	// Calculate array dimension and component type name
	//
	int n = 1;
	Class<?> componentType = arrayClass.getComponentType();
	while (componentType.isArray()) {
	n++;
	componentType = componentType.getComponentType();
	}
	String componentTypeName = componentType.getName();

	// Check if the array's component type is a primitive type
	//
	if (!componentType.isPrimitive()) {
	throw new IllegalArgumentException(
	"component type of the array must be a primitive type");
	}

	// Map component type name to corresponding SimpleType
	//
	final SimpleType<?> simpleType =
	getPrimitiveOpenType(componentTypeName);

	// Build primitive array
	//
	try {
	@SuppressWarnings("rawtypes")
	ArrayType at = new ArrayType(simpleType, true);
	if (n > 1)
	at = new ArrayType<T>(n - 1, at);
	return at;
	} catch (OpenDataException e) {
	throw new IllegalArgumentException(e); // should not happen
	}
	}

	/**
	* Replace/resolve the object read from the stream before it is returned
	* to the caller.
	*
	* @serialData The new serial form of this class defines a new serializable
	* {@code boolean} field {@code 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
	* {@code ArrayType} instance describes a primitive type array. So when
	* {@code primitiveArray} is {@code true} the {@code className},
	* {@code typeName} and {@code description} serializable fields
	* are converted into primitive types before the deserialized
	* {@code ArrayType} instance is return to the caller. The
	* {@code elementType} field always returns the {@code SimpleType}
	* corresponding to the primitive wrapper type of the array's
	* primitive type.
	* <p>
	* Therefore the following serializable fields are deserialized as follows:
	* <ul>
	* <li>if {@code primitiveArray} is {@code true} the {@code className}
	* field is deserialized by replacing the array's component primitive
	* wrapper type by the corresponding array's component primitive type,
	* e.g. {@code "[[Ljava.lang.Integer;"} will be deserialized as
	* {@code "[[I"}.</li>
	* <li>if {@code primitiveArray} is {@code true} the {@code typeName}
	* field is deserialized by replacing the array's component primitive
	* wrapper type by the corresponding array's component primitive type,
	* e.g. {@code "[[Ljava.lang.Integer;"} will be deserialized as
	* {@code "[[I"}.</li>
	* <li>if {@code primitiveArray} is {@code true} the {@code description}
	* field is deserialized by replacing the array's component primitive
	* wrapper type by the corresponding array's component primitive type,
	* e.g. {@code "2-dimension array of java.lang.Integer"} will be
	* deserialized as {@code "2-dimension array of int"}.</li>
	* </ul>
	*
	* @since 1.6
	*/
	private Object readResolve() throws ObjectStreamException {
	if (primitiveArray) {
	return convertFromWrapperToPrimitiveTypes();
	} else {
	return this;
	}
	}

	private <T> ArrayType<T> convertFromWrapperToPrimitiveTypes() {
	String cn = getClassName();
	String tn = getTypeName();
	String d = getDescription();
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (cn.indexOf((String)typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]) != -1) {
	cn = cn.replaceFirst(
	"L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";",
	(String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]);
	tn = tn.replaceFirst(
	"L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";",
	(String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]);
	d = d.replaceFirst(
	(String) typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX],
	(String) typeDescr[PRIMITIVE_TYPE_NAME_INDEX]);
	break;
	}
	}
	return new ArrayType<T>(cn, tn, d,
	dimension, elementType, primitiveArray);
	}

	/**
	* Nominate a replacement for this object in the stream before the object
	* is written.
	*
	* @serialData The new serial form of this class defines a new serializable
	* {@code boolean} field {@code 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
	* {@code ArrayType} instance describes a primitive type array. So when
	* {@code primitiveArray} is {@code true} the {@code className},
	* {@code typeName} and {@code description} serializable fields
	* are converted into wrapper types before the serialized
	* {@code ArrayType} instance is written to the stream. The
	* {@code elementType} field always returns the {@code SimpleType}
	* corresponding to the primitive wrapper type of the array's
	* primitive type.
	* <p>
	* Therefore the following serializable fields are serialized as follows:
	* <ul>
	* <li>if {@code primitiveArray} is {@code true} the {@code className}
	* field is serialized by replacing the array's component primitive
	* type by the corresponding array's component primitive wrapper type,
	* e.g. {@code "[[I"} will be serialized as
	* {@code "[[Ljava.lang.Integer;"}.</li>
	* <li>if {@code primitiveArray} is {@code true} the {@code typeName}
	* field is serialized by replacing the array's component primitive
	* type by the corresponding array's component primitive wrapper type,
	* e.g. {@code "[[I"} will be serialized as
	* {@code "[[Ljava.lang.Integer;"}.</li>
	* <li>if {@code primitiveArray} is {@code true} the {@code description}
	* field is serialized by replacing the array's component primitive
	* type by the corresponding array's component primitive wrapper type,
	* e.g. {@code "2-dimension array of int"} will be serialized as
	* {@code "2-dimension array of java.lang.Integer"}.</li>
	* </ul>
	*
	* @since 1.6
	*/
	private Object writeReplace() throws ObjectStreamException {
	if (primitiveArray) {
	return convertFromPrimitiveToWrapperTypes();
	} else {
	return this;
	}
	}

	private <T> ArrayType<T> convertFromPrimitiveToWrapperTypes() {
	String cn = getClassName();
	String tn = getTypeName();
	String d = getDescription();
	for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
	if (cn.indexOf((String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]) != -1) {
	cn = cn.replaceFirst(
	(String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX],
	"L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";");
	tn = tn.replaceFirst(
	(String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX],
	"L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";");
	d = d.replaceFirst(
	(String) typeDescr[PRIMITIVE_TYPE_NAME_INDEX],
	(String) typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]);
	break;
	}
	}
	return new ArrayType<T>(cn, tn, d,
	dimension, elementType, primitiveArray);
	}
	}

Back to index...