1 /*
2 * Copyright 2000-2007 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 package javax.management.openmbean;
27
28 import java.io.ObjectStreamException;
29 import java.lang.reflect.Array;
30
31 /**
32 * The <code>ArrayType</code> class is the <i>open type</i> class whose instances describe
33 * all <i>open data</i> values which are n-dimensional arrays of <i>open data</i> values.
34 * <p>
35 * Examples of valid {@code ArrayType} instances are:
36 * <pre>
37 * // 2-dimension array of java.lang.String
38 * ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);
39 *
40 * // 1-dimension array of int
41 * ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);
42 *
43 * // 1-dimension array of java.lang.Integer
44 * ArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false);
45 *
46 * // 4-dimension array of int
47 * ArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2);
48 *
49 * // 4-dimension array of java.lang.Integer
50 * ArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3);
51 *
52 * // 1-dimension array of java.lang.String
53 * ArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false);
54 *
55 * // 1-dimension array of long
56 * ArrayType<long[]> a7 = new ArrayType<long[]>(SimpleType.LONG, true);
57 *
58 * // 1-dimension array of java.lang.Integer
59 * ArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER);
60 *
61 * // 2-dimension array of java.lang.Integer
62 * ArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8);
63 *
64 * // 2-dimension array of int
65 * ArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class);
66 *
67 * // 3-dimension array of int
68 * ArrayType<int[][][]> a11 = ArrayType.getArrayType(a10);
69 *
70 * // 1-dimension array of float
71 * ArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class);
72 *
73 * // 2-dimension array of float
74 * ArrayType<float[][]> a13 = ArrayType.getArrayType(a12);
75 *
76 * // 1-dimension array of javax.management.ObjectName
77 * ArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME);
78 *
79 * // 2-dimension array of javax.management.ObjectName
80 * ArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14);
81 *
82 * // 3-dimension array of java.lang.String
83 * ArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING);
84 *
85 * // 1-dimension array of java.lang.String
86 * ArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING);
87 *
88 * // 2-dimension array of java.lang.String
89 * ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);
90 *
91 * // 3-dimension array of java.lang.String
92 * ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
93 * </pre>
94 *
95 *
96 * @since 1.5
97 */
98 /*
99 Generification note: we could have defined a type parameter that is the
100 element type, with class ArrayType<E> extends OpenType<E[]>. However,
101 that doesn't buy us all that much. We can't say
102 public OpenType<E> getElementOpenType()
103 because this ArrayType could be a multi-dimensional array.
104 For example, if we had
105 ArrayType(2, SimpleType.INTEGER)
106 then E would have to be Integer[], while getElementOpenType() would
107 return SimpleType.INTEGER, which is an OpenType<Integer>.
108
109 Furthermore, we would like to support int[] (as well as Integer[]) as
110 an Open Type (RFE 5045358). We would want this to be an OpenType<int[]>
111 which can't be expressed as <E[]> because E can't be a primitive type
112 like int.
113 */
114 public class ArrayType<T> extends OpenType<T> {
115
116 /* Serial version */
117 static final long serialVersionUID = 720504429830309770L;
118
119 /**
120 * @serial The dimension of arrays described by this {@link ArrayType}
121 * instance.
122 */
123 private int dimension;
124
125 /**
126 * @serial The <i>open type</i> of element values contained in the arrays
127 * described by this {@link ArrayType} instance.
128 */
129 private OpenType<?> elementType;
130
131 /**
132 * @serial This flag indicates whether this {@link ArrayType}
133 * describes a primitive array.
134 *
135 * @since 1.6
136 */
137 private boolean primitiveArray;
138
139 private transient Integer myHashCode = null; // As this instance is immutable, these two values
140 private transient String myToString = null; // need only be calculated once.
141
142 // indexes refering to columns in the PRIMITIVE_ARRAY_TYPES table.
143 private static final int PRIMITIVE_WRAPPER_NAME_INDEX = 0;
144 private static final int PRIMITIVE_TYPE_NAME_INDEX = 1;
145 private static final int PRIMITIVE_TYPE_KEY_INDEX = 2;
146 private static final int PRIMITIVE_OPEN_TYPE_INDEX = 3;
147
148 private static final Object[][] PRIMITIVE_ARRAY_TYPES = {
149 { Boolean.class.getName(), boolean.class.getName(), "Z", SimpleType.BOOLEAN },
150 { Character.class.getName(), char.class.getName(), "C", SimpleType.CHARACTER },
151 { Byte.class.getName(), byte.class.getName(), "B", SimpleType.BYTE },
152 { Short.class.getName(), short.class.getName(), "S", SimpleType.SHORT },
153 { Integer.class.getName(), int.class.getName(), "I", SimpleType.INTEGER },
154 { Long.class.getName(), long.class.getName(), "J", SimpleType.LONG },
155 { Float.class.getName(), float.class.getName(), "F", SimpleType.FLOAT },
156 { Double.class.getName(), double.class.getName(), "D", SimpleType.DOUBLE }
157 };
158
159 static boolean isPrimitiveContentType(final String primitiveKey) {
160 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
161 if (typeDescr[PRIMITIVE_TYPE_KEY_INDEX].equals(primitiveKey)) {
162 return true;
163 }
164 }
165 return false;
166 }
167
168 /**
169 * Return the key used to identify the element type in
170 * arrays - e.g. "Z" for boolean, "C" for char etc...
171 * @param elementClassName the wrapper class name of the array
172 * element ("Boolean", "Character", etc...)
173 * @return the key corresponding to the given type ("Z", "C", etc...)
174 * return null if the given elementClassName is not a primitive
175 * wrapper class name.
176 **/
177 static String getPrimitiveTypeKey(String elementClassName) {
178 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
179 if (elementClassName.equals(typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]))
180 return (String)typeDescr[PRIMITIVE_TYPE_KEY_INDEX];
181 }
182 return null;
183 }
184
185 /**
186 * Return the primitive type name corresponding to the given wrapper class.
187 * e.g. "boolean" for "Boolean", "char" for "Character" etc...
188 * @param elementClassName the type of the array element ("Boolean",
189 * "Character", etc...)
190 * @return the primitive type name corresponding to the given wrapper class
191 * ("boolean", "char", etc...)
192 * return null if the given elementClassName is not a primitive
193 * wrapper type name.
194 **/
195 static String getPrimitiveTypeName(String elementClassName) {
196 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
197 if (elementClassName.equals(typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]))
198 return (String)typeDescr[PRIMITIVE_TYPE_NAME_INDEX];
199 }
200 return null;
201 }
202
203 /**
204 * Return the primitive open type corresponding to the given primitive type.
205 * e.g. SimpleType.BOOLEAN for "boolean", SimpleType.CHARACTER for
206 * "char", etc...
207 * @param primitiveTypeName the primitive type of the array element ("boolean",
208 * "char", etc...)
209 * @return the OpenType corresponding to the given primitive type name
210 * (SimpleType.BOOLEAN, SimpleType.CHARACTER, etc...)
211 * return null if the given elementClassName is not a primitive
212 * type name.
213 **/
214 static SimpleType<?> getPrimitiveOpenType(String primitiveTypeName) {
215 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
216 if (primitiveTypeName.equals(typeDescr[PRIMITIVE_TYPE_NAME_INDEX]))
217 return (SimpleType<?>)typeDescr[PRIMITIVE_OPEN_TYPE_INDEX];
218 }
219 return null;
220 }
221
222 /* *** Constructor *** */
223
224 /**
225 * Constructs an <tt>ArrayType</tt> instance describing <i>open data</i> values which are
226 * arrays with dimension <var>dimension</var> of elements whose <i>open type</i> is <var>elementType</var>.
227 * <p>
228 * When invoked on an <tt>ArrayType</tt> instance, the {@link OpenType#getClassName() getClassName} method
229 * returns the class name of the array instances it describes (following the rules defined by the
230 * {@link Class#getName() getName} method of <code>java.lang.Class</code>), not the class name of the array elements
231 * (which is returned by a call to <tt>getElementOpenType().getClassName()</tt>).
232 * <p>
233 * The internal field corresponding to the type name of this <code>ArrayType</code> instance is also set to
234 * the class name of the array instances it describes.
235 * In other words, the methods <code>getClassName</code> and <code>getTypeName</code> return the same string value.
236 * The internal field corresponding to the description of this <code>ArrayType</code> instance is set to a string value
237 * which follows the following template:
238 * <ul>
239 * <li>if non-primitive array: <tt><i><dimension></i>-dimension array of <i><element_class_name></i></tt></li>
240 * <li>if primitive array: <tt><i><dimension></i>-dimension array of <i><primitive_type_of_the_element_class_name></i></tt></li>
241 * </ul>
242 * <p>
243 * As an example, the following piece of code:
244 * <pre>
245 * ArrayType<String[][][]> t = new ArrayType<String[][][]>(3, SimpleType.STRING);
246 * System.out.println("array class name = " + t.getClassName());
247 * System.out.println("element class name = " + t.getElementOpenType().getClassName());
248 * System.out.println("array type name = " + t.getTypeName());
249 * System.out.println("array type description = " + t.getDescription());
250 * </pre>
251 * would produce the following output:
252 * <pre>
253 * array class name = [[[Ljava.lang.String;
254 * element class name = java.lang.String
255 * array type name = [[[Ljava.lang.String;
256 * array type description = 3-dimension array of java.lang.String
257 * </pre>
258 * And the following piece of code which is equivalent to the one listed
259 * above would also produce the same output:
260 * <pre>
261 * ArrayType<String[]> t1 = new ArrayType<String[]>(1, SimpleType.STRING);
262 * ArrayType<String[][]> t2 = new ArrayType<String[][]>(1, t1);
263 * ArrayType<String[][][]> t3 = new ArrayType<String[][][]>(1, t2);
264 * System.out.println("array class name = " + t3.getClassName());
265 * System.out.println("element class name = " + t3.getElementOpenType().getClassName());
266 * System.out.println("array type name = " + t3.getTypeName());
267 * System.out.println("array type description = " + t3.getDescription());
268 * </pre>
269 *
270 * @param dimension the dimension of arrays described by this <tt>ArrayType</tt> instance;
271 * must be greater than or equal to 1.
272 *
273 * @param elementType the <i>open type</i> of element values contained
274 * in the arrays described by this <tt>ArrayType</tt>
275 * instance; must be an instance of either
276 * <tt>SimpleType</tt>, <tt>CompositeType</tt>,
277 * <tt>TabularType</tt> or another <tt>ArrayType</tt>
278 * with a <tt>SimpleType</tt>, <tt>CompositeType</tt>
279 * or <tt>TabularType</tt> as its <tt>elementType</tt>.
280 *
281 * @throws IllegalArgumentException if {@code dimension} is not a positive
282 * integer.
283 * @throws OpenDataException if <var>elementType's className</var> is not
284 * one of the allowed Java class names for open
285 * data.
286 */
287 public ArrayType(int dimension,
288 OpenType<?> elementType) throws OpenDataException {
289 // Check and construct state defined by parent.
290 // We can't use the package-private OpenType constructor because
291 // we don't know if the elementType parameter is sane.
292 super(buildArrayClassName(dimension, elementType),
293 buildArrayClassName(dimension, elementType),
294 buildArrayDescription(dimension, elementType));
295
296 // Check and construct state specific to ArrayType
297 //
298 if (elementType.isArray()) {
299 ArrayType at = (ArrayType) elementType;
300 this.dimension = at.getDimension() + dimension;
301 this.elementType = at.getElementOpenType();
302 this.primitiveArray = at.isPrimitiveArray();
303 } else {
304 this.dimension = dimension;
305 this.elementType = elementType;
306 this.primitiveArray = false;
307 }
308 }
309
310 /**
311 * Constructs a unidimensional {@code ArrayType} instance for the
312 * supplied {@code SimpleType}.
313 * <p>
314 * This constructor supports the creation of arrays of primitive
315 * types when {@code primitiveArray} is {@code true}.
316 * <p>
317 * For primitive arrays the {@link #getElementOpenType()} method
318 * returns the {@link SimpleType} corresponding to the wrapper
319 * type of the primitive type of the array.
320 * <p>
321 * When invoked on an <tt>ArrayType</tt> instance, the {@link OpenType#getClassName() getClassName} method
322 * returns the class name of the array instances it describes (following the rules defined by the
323 * {@link Class#getName() getName} method of <code>java.lang.Class</code>), not the class name of the array elements
324 * (which is returned by a call to <tt>getElementOpenType().getClassName()</tt>).
325 * <p>
326 * The internal field corresponding to the type name of this <code>ArrayType</code> instance is also set to
327 * the class name of the array instances it describes.
328 * In other words, the methods <code>getClassName</code> and <code>getTypeName</code> return the same string value.
329 * The internal field corresponding to the description of this <code>ArrayType</code> instance is set to a string value
330 * which follows the following template:
331 * <ul>
332 * <li>if non-primitive array: <tt>1-dimension array of <i><element_class_name></i></tt></li>
333 * <li>if primitive array: <tt>1-dimension array of <i><primitive_type_of_the_element_class_name></i></tt></li>
334 * </ul>
335 * <p>
336 * As an example, the following piece of code:
337 * <pre>
338 * ArrayType<int[]> t = new ArrayType<int[]>(SimpleType.INTEGER, true);
339 * System.out.println("array class name = " + t.getClassName());
340 * System.out.println("element class name = " + t.getElementOpenType().getClassName());
341 * System.out.println("array type name = " + t.getTypeName());
342 * System.out.println("array type description = " + t.getDescription());
343 * </pre>
344 * would produce the following output:
345 * <pre>
346 * array class name = [I
347 * element class name = java.lang.Integer
348 * array type name = [I
349 * array type description = 1-dimension array of int
350 * </pre>
351 *
352 * @param elementType the {@code SimpleType} of the element values
353 * contained in the arrays described by this
354 * {@code ArrayType} instance.
355 *
356 * @param primitiveArray {@code true} when this array describes
357 * primitive arrays.
358 *
359 * @throws IllegalArgumentException if {@code dimension} is not a positive
360 * integer.
361 * @throws OpenDataException if {@code primitiveArray} is {@code true} and
362 * {@code elementType} is not a valid {@code SimpleType} for a primitive
363 * type.
364 *
365 * @since 1.6
366 */
367 public ArrayType(SimpleType<?> elementType,
368 boolean primitiveArray) throws OpenDataException {
369
370 // Check and construct state defined by parent.
371 // We can call the package-private OpenType constructor because the
372 // set of SimpleTypes is fixed and SimpleType can't be subclassed.
373 super(buildArrayClassName(1, elementType, primitiveArray),
374 buildArrayClassName(1, elementType, primitiveArray),
375 buildArrayDescription(1, elementType, primitiveArray),
376 true);
377
378 // Check and construct state specific to ArrayType
379 //
380 this.dimension = 1;
381 this.elementType = elementType;
382 this.primitiveArray = primitiveArray;
383 }
384
385 /* Package-private constructor for callers we trust to get it right. */
386 ArrayType(String className, String typeName, String description,
387 int dimension, OpenType elementType,
388 boolean primitiveArray) {
389 super(className, typeName, description, true);
390 this.dimension = dimension;
391 this.elementType = elementType;
392 this.primitiveArray = primitiveArray;
393 }
394
395 private static String buildArrayClassName(int dimension,
396 OpenType<?> elementType)
397 throws OpenDataException {
398 boolean isPrimitiveArray = false;
399 if (elementType.isArray()) {
400 isPrimitiveArray = ((ArrayType) elementType).isPrimitiveArray();
401 }
402 return buildArrayClassName(dimension, elementType, isPrimitiveArray);
403 }
404
405 private static String buildArrayClassName(int dimension,
406 OpenType<?> elementType,
407 boolean isPrimitiveArray)
408 throws OpenDataException {
409 if (dimension < 1) {
410 throw new IllegalArgumentException(
411 "Value of argument dimension must be greater than 0");
412 }
413 StringBuilder result = new StringBuilder();
414 String elementClassName = elementType.getClassName();
415 // Add N (= dimension) additional '[' characters to the existing array
416 for (int i = 1; i <= dimension; i++) {
417 result.append('[');
418 }
419 if (elementType.isArray()) {
420 result.append(elementClassName);
421 } else {
422 if (isPrimitiveArray) {
423 final String key = getPrimitiveTypeKey(elementClassName);
424 // Ideally we should throw an IllegalArgumentException here,
425 // but for compatibility reasons we throw an OpenDataException.
426 // (used to be thrown by OpenType() constructor).
427 //
428 if (key == null)
429 throw new OpenDataException("Element type is not primitive: "
430 + elementClassName);
431 result.append(key);
432 } else {
433 result.append("L");
434 result.append(elementClassName);
435 result.append(';');
436 }
437 }
438 return result.toString();
439 }
440
441 private static String buildArrayDescription(int dimension,
442 OpenType<?> elementType)
443 throws OpenDataException {
444 boolean isPrimitiveArray = false;
445 if (elementType.isArray()) {
446 isPrimitiveArray = ((ArrayType) elementType).isPrimitiveArray();
447 }
448 return buildArrayDescription(dimension, elementType, isPrimitiveArray);
449 }
450
451 private static String buildArrayDescription(int dimension,
452 OpenType<?> elementType,
453 boolean isPrimitiveArray)
454 throws OpenDataException {
455 if (elementType.isArray()) {
456 ArrayType at = (ArrayType) elementType;
457 dimension += at.getDimension();
458 elementType = at.getElementOpenType();
459 isPrimitiveArray = at.isPrimitiveArray();
460 }
461 StringBuilder result =
462 new StringBuilder(dimension + "-dimension array of ");
463 final String elementClassName = elementType.getClassName();
464 if (isPrimitiveArray) {
465 // Convert from wrapper type to primitive type
466 final String primitiveType =
467 getPrimitiveTypeName(elementClassName);
468
469 // Ideally we should throw an IllegalArgumentException here,
470 // but for compatibility reasons we throw an OpenDataException.
471 // (used to be thrown by OpenType() constructor).
472 //
473 if (primitiveType == null)
474 throw new OpenDataException("Element is not a primitive type: "+
475 elementClassName);
476 result.append(primitiveType);
477 } else {
478 result.append(elementClassName);
479 }
480 return result.toString();
481 }
482
483 /* *** ArrayType specific information methods *** */
484
485 /**
486 * Returns the dimension of arrays described by this <tt>ArrayType</tt> instance.
487 *
488 * @return the dimension.
489 */
490 public int getDimension() {
491
492 return dimension;
493 }
494
495 /**
496 * Returns the <i>open type</i> of element values contained in the arrays described by this <tt>ArrayType</tt> instance.
497 *
498 * @return the element type.
499 */
500 public OpenType<?> getElementOpenType() {
501
502 return elementType;
503 }
504
505 /**
506 * Returns <code>true</code> if the open data values this open
507 * type describes are primitive arrays, <code>false</code> otherwise.
508 *
509 * @return true if this is a primitive array type.
510 *
511 * @since 1.6
512 */
513 public boolean isPrimitiveArray() {
514
515 return primitiveArray;
516 }
517
518 /**
519 * Tests whether <var>obj</var> is a value for this <code>ArrayType</code>
520 * instance.
521 * <p>
522 * This method returns <code>true</code> if and only if <var>obj</var>
523 * is not null, <var>obj</var> is an array and any one of the following
524 * is <tt>true</tt>:
525 *
526 * <ul>
527 * <li>if this <code>ArrayType</code> instance describes an array of
528 * <tt>SimpleType</tt> elements or their corresponding primitive types,
529 * <var>obj</var>'s class name is the same as the className field defined
530 * for this <code>ArrayType</code> instance (i.e. the class name returned
531 * by the {@link OpenType#getClassName() getClassName} method, which
532 * includes the dimension information),<br> </li>
533 * <li>if this <code>ArrayType</code> instance describes an array of
534 * classes implementing the {@code TabularData} interface or the
535 * {@code CompositeData} interface, <var>obj</var> is assignable to
536 * such a declared array, and each element contained in <var>obj</var>
537 * is either null or a valid value for the element's open type specified
538 * by this <code>ArrayType</code> instance.</li>
539 * </ul>
540 *
541 * @param obj the object to be tested.
542 *
543 * @return <code>true</code> if <var>obj</var> is a value for this
544 * <code>ArrayType</code> instance.
545 */
546 public boolean isValue(Object obj) {
547
548 // if obj is null, return false
549 //
550 if (obj == null) {
551 return false;
552 }
553
554 Class objClass = obj.getClass();
555 String objClassName = objClass.getName();
556
557 // if obj is not an array, return false
558 //
559 if ( ! objClass.isArray() ) {
560 return false;
561 }
562
563 // Test if obj's class name is the same as for the array values that this instance describes
564 // (this is fine if elements are of simple types, which are final classes)
565 //
566 if ( this.getClassName().equals(objClassName) ) {
567 return true;
568 }
569
570 // In case this ArrayType instance describes an array of classes implementing the TabularData or CompositeData interface,
571 // we first check for the assignability of obj to such an array of TabularData or CompositeData,
572 // which ensures that:
573 // . obj is of the the same dimension as this ArrayType instance,
574 // . it is declared as an array of elements which are either all TabularData or all CompositeData.
575 //
576 // If the assignment check is positive,
577 // then we have to check that each element in obj is of the same TabularType or CompositeType
578 // as the one described by this ArrayType instance.
579 //
580 // [About assignment check, note that the call below returns true: ]
581 // [Class.forName("[Lpackage.CompositeData;").isAssignableFrom(Class.forName("[Lpackage.CompositeDataImpl;)")); ]
582 //
583 if ( (this.elementType.getClassName().equals(TabularData.class.getName())) ||
584 (this.elementType.getClassName().equals(CompositeData.class.getName())) ) {
585
586 boolean isTabular =
587 (elementType.getClassName().equals(TabularData.class.getName()));
588 int[] dims = new int[getDimension()];
589 Class<?> elementClass = isTabular ? TabularData.class : CompositeData.class;
590 Class<?> targetClass = Array.newInstance(elementClass, dims).getClass();
591
592 // assignment check: return false if negative
593 if ( ! targetClass.isAssignableFrom(objClass) ) {
594 return false;
595 }
596
597 // check that all elements in obj are valid values for this ArrayType
598 if ( ! checkElementsType( (Object[]) obj, this.dimension) ) { // we know obj's dimension is this.dimension
599 return false;
600 }
601
602 return true;
603 }
604
605 // if previous tests did not return, then obj is not a value for this ArrayType instance
606 return false;
607 }
608
609 /**
610 * Returns true if and only if all elements contained in the array argument x_dim_Array of dimension dim
611 * are valid values (ie either null or of the right openType)
612 * for the element open type specified by this ArrayType instance.
613 *
614 * This method's implementation uses recursion to go down the dimensions of the array argument.
615 */
616 private boolean checkElementsType(Object[] x_dim_Array, int dim) {
617
618 // if the elements of x_dim_Array are themselves array: go down recursively....
619 if ( dim > 1 ) {
620 for (int i=0; i<x_dim_Array.length; i++) {
621 if ( ! checkElementsType((Object[])x_dim_Array[i], dim-1) ) {
622 return false;
623 }
624 }
625 return true;
626 }
627 // ...else, for a non-empty array, each element must be a valid value: either null or of the right openType
628 else {
629 for (int i=0; i<x_dim_Array.length; i++) {
630 if ( (x_dim_Array[i] != null) && (! this.getElementOpenType().isValue(x_dim_Array[i])) ) {
631 return false;
632 }
633 }
634 return true;
635 }
636 }
637
638 @Override
639 boolean isAssignableFrom(OpenType ot) {
640 if (!(ot instanceof ArrayType))
641 return false;
642 ArrayType<?> at = (ArrayType<?>) ot;
643 return (at.getDimension() == getDimension() &&
644 at.isPrimitiveArray() == isPrimitiveArray() &&
645 at.getElementOpenType().isAssignableFrom(getElementOpenType()));
646 }
647
648
649 /* *** Methods overriden from class Object *** */
650
651 /**
652 * Compares the specified <code>obj</code> parameter with this
653 * <code>ArrayType</code> instance for equality.
654 * <p>
655 * Two <code>ArrayType</code> instances are equal if and only if they
656 * describe array instances which have the same dimension, elements'
657 * open type and primitive array flag.
658 *
659 * @param obj the object to be compared for equality with this
660 * <code>ArrayType</code> instance; if <var>obj</var>
661 * is <code>null</code> or is not an instance of the
662 * class <code>ArrayType</code> this method returns
663 * <code>false</code>.
664 *
665 * @return <code>true</code> if the specified object is equal to
666 * this <code>ArrayType</code> instance.
667 */
668 public boolean equals(Object obj) {
669
670 // if obj is null, return false
671 //
672 if (obj == null) {
673 return false;
674 }
675
676 // if obj is not an ArrayType, return false
677 //
678 if (!(obj instanceof ArrayType))
679 return false;
680 ArrayType other = (ArrayType) obj;
681
682 // if other's dimension is different than this instance's, return false
683 //
684 if (this.dimension != other.dimension) {
685 return false;
686 }
687
688 // Test if other's elementType field is the same as for this instance
689 //
690 if (!this.elementType.equals(other.elementType)) {
691 return false;
692 }
693
694 // Test if other's primitiveArray flag is the same as for this instance
695 //
696 return this.primitiveArray == other.primitiveArray;
697 }
698
699 /**
700 * Returns the hash code value for this <code>ArrayType</code> instance.
701 * <p>
702 * The hash code of an <code>ArrayType</code> instance is the sum of the
703 * hash codes of all the elements of information used in <code>equals</code>
704 * comparisons (i.e. dimension, elements' open type and primitive array flag).
705 * The hashcode for a primitive value is the hashcode of the corresponding boxed
706 * object (e.g. the hashcode for <tt>true</tt> is <tt>Boolean.TRUE.hashCode()</tt>).
707 * This ensures that <code> t1.equals(t2) </code> implies that
708 * <code> t1.hashCode()==t2.hashCode() </code> for any two
709 * <code>ArrayType</code> instances <code>t1</code> and <code>t2</code>,
710 * as required by the general contract of the method
711 * {@link Object#hashCode() Object.hashCode()}.
712 * <p>
713 * As <code>ArrayType</code> instances are immutable, the hash
714 * code for this instance is calculated once, on the first call
715 * to <code>hashCode</code>, and then the same value is returned
716 * for subsequent calls.
717 *
718 * @return the hash code value for this <code>ArrayType</code> instance
719 */
720 public int hashCode() {
721
722 // Calculate the hash code value if it has not yet been done (ie 1st call to hashCode())
723 //
724 if (myHashCode == null) {
725 int value = 0;
726 value += dimension;
727 value += elementType.hashCode();
728 value += Boolean.valueOf(primitiveArray).hashCode();
729 myHashCode = Integer.valueOf(value);
730 }
731
732 // return always the same hash code for this instance (immutable)
733 //
734 return myHashCode.intValue();
735 }
736
737 /**
738 * Returns a string representation of this <code>ArrayType</code> instance.
739 * <p>
740 * The string representation consists of the name of this class (i.e.
741 * <code>javax.management.openmbean.ArrayType</code>), the type name,
742 * the dimension, the elements' open type and the primitive array flag
743 * defined for this instance.
744 * <p>
745 * As <code>ArrayType</code> instances are immutable, the
746 * string representation for this instance is calculated
747 * once, on the first call to <code>toString</code>, and
748 * then the same value is returned for subsequent calls.
749 *
750 * @return a string representation of this <code>ArrayType</code> instance
751 */
752 public String toString() {
753
754 // Calculate the string representation if it has not yet been done (ie 1st call to toString())
755 //
756 if (myToString == null) {
757 myToString = getClass().getName() +
758 "(name=" + getTypeName() +
759 ",dimension=" + dimension +
760 ",elementType=" + elementType +
761 ",primitiveArray=" + primitiveArray + ")";
762 }
763
764 // return always the same string representation for this instance (immutable)
765 //
766 return myToString;
767 }
768
769 /**
770 * Create an {@code ArrayType} instance in a type-safe manner.
771 * <p>
772 * Multidimensional arrays can be built up by calling this method as many
773 * times as necessary.
774 * <p>
775 * Calling this method twice with the same parameters may return the same
776 * object or two equal but not identical objects.
777 * <p>
778 * As an example, the following piece of code:
779 * <pre>
780 * ArrayType<String[]> t1 = ArrayType.getArrayType(SimpleType.STRING);
781 * ArrayType<String[][]> t2 = ArrayType.getArrayType(t1);
782 * ArrayType<String[][][]> t3 = ArrayType.getArrayType(t2);
783 * System.out.println("array class name = " + t3.getClassName());
784 * System.out.println("element class name = " + t3.getElementOpenType().getClassName());
785 * System.out.println("array type name = " + t3.getTypeName());
786 * System.out.println("array type description = " + t3.getDescription());
787 * </pre>
788 * would produce the following output:
789 * <pre>
790 * array class name = [[[Ljava.lang.String;
791 * element class name = java.lang.String
792 * array type name = [[[Ljava.lang.String;
793 * array type description = 3-dimension array of java.lang.String
794 * </pre>
795 *
796 * @param elementType the <i>open type</i> of element values contained
797 * in the arrays described by this <tt>ArrayType</tt>
798 * instance; must be an instance of either
799 * <tt>SimpleType</tt>, <tt>CompositeType</tt>,
800 * <tt>TabularType</tt> or another <tt>ArrayType</tt>
801 * with a <tt>SimpleType</tt>, <tt>CompositeType</tt>
802 * or <tt>TabularType</tt> as its <tt>elementType</tt>.
803 *
804 * @throws OpenDataException if <var>elementType's className</var> is not
805 * one of the allowed Java class names for open
806 * data.
807 *
808 * @since 1.6
809 */
810 public static <E> ArrayType<E[]> getArrayType(OpenType<E> elementType)
811 throws OpenDataException {
812 return new ArrayType<E[]>(1, elementType);
813 }
814
815 /**
816 * Create an {@code ArrayType} instance in a type-safe manner.
817 * <p>
818 * Calling this method twice with the same parameters may return the
819 * same object or two equal but not identical objects.
820 * <p>
821 * As an example, the following piece of code:
822 * <pre>
823 * ArrayType<int[][][]> t = ArrayType.getPrimitiveArrayType(int[][][].class);
824 * System.out.println("array class name = " + t.getClassName());
825 * System.out.println("element class name = " + t.getElementOpenType().getClassName());
826 * System.out.println("array type name = " + t.getTypeName());
827 * System.out.println("array type description = " + t.getDescription());
828 * </pre>
829 * would produce the following output:
830 * <pre>
831 * array class name = [[[I
832 * element class name = java.lang.Integer
833 * array type name = [[[I
834 * array type description = 3-dimension array of int
835 * </pre>
836 *
837 * @param arrayClass a primitive array class such as {@code int[].class},
838 * {@code boolean[][].class}, etc. The {@link
839 * #getElementOpenType()} method of the returned
840 * {@code ArrayType} returns the {@link SimpleType}
841 * corresponding to the wrapper type of the primitive
842 * type of the array.
843 *
844 * @throws IllegalArgumentException if <var>arrayClass</var> is not
845 * a primitive array.
846 *
847 * @since 1.6
848 */
849 @SuppressWarnings("unchecked") // can't get appropriate T for primitive array
850 public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> arrayClass) {
851 // Check if the supplied parameter is an array
852 //
853 if (!arrayClass.isArray()) {
854 throw new IllegalArgumentException("arrayClass must be an array");
855 }
856
857 // Calculate array dimension and component type name
858 //
859 int n = 1;
860 Class<?> componentType = arrayClass.getComponentType();
861 while (componentType.isArray()) {
862 n++;
863 componentType = componentType.getComponentType();
864 }
865 String componentTypeName = componentType.getName();
866
867 // Check if the array's component type is a primitive type
868 //
869 if (!componentType.isPrimitive()) {
870 throw new IllegalArgumentException(
871 "component type of the array must be a primitive type");
872 }
873
874 // Map component type name to corresponding SimpleType
875 //
876 final SimpleType<?> simpleType =
877 getPrimitiveOpenType(componentTypeName);
878
879 // Build primitive array
880 //
881 try {
882 ArrayType at = new ArrayType(simpleType, true);
883 if (n > 1)
884 at = new ArrayType<T>(n - 1, at);
885 return at;
886 } catch (OpenDataException e) {
887 throw new IllegalArgumentException(e); // should not happen
888 }
889 }
890
891 /**
892 * Replace/resolve the object read from the stream before it is returned
893 * to the caller.
894 *
895 * @serialData The new serial form of this class defines a new serializable
896 * {@code boolean} field {@code primitiveArray}. In order to guarantee the
897 * interoperability with previous versions of this class the new serial
898 * form must continue to refer to primitive wrapper types even when the
899 * {@code ArrayType} instance describes a primitive type array. So when
900 * {@code primitiveArray} is {@code true} the {@code className},
901 * {@code typeName} and {@code description} serializable fields
902 * are converted into primitive types before the deserialized
903 * {@code ArrayType} instance is return to the caller. The
904 * {@code elementType} field always returns the {@code SimpleType}
905 * corresponding to the primitive wrapper type of the array's
906 * primitive type.
907 * <p>
908 * Therefore the following serializable fields are deserialized as follows:
909 * <ul>
910 * <li>if {@code primitiveArray} is {@code true} the {@code className}
911 * field is deserialized by replacing the array's component primitive
912 * wrapper type by the corresponding array's component primitive type,
913 * e.g. {@code "[[Ljava.lang.Integer;"} will be deserialized as
914 * {@code "[[I"}.</li>
915 * <li>if {@code primitiveArray} is {@code true} the {@code typeName}
916 * field is deserialized by replacing the array's component primitive
917 * wrapper type by the corresponding array's component primitive type,
918 * e.g. {@code "[[Ljava.lang.Integer;"} will be deserialized as
919 * {@code "[[I"}.</li>
920 * <li>if {@code primitiveArray} is {@code true} the {@code description}
921 * field is deserialized by replacing the array's component primitive
922 * wrapper type by the corresponding array's component primitive type,
923 * e.g. {@code "2-dimension array of java.lang.Integer"} will be
924 * deserialized as {@code "2-dimension array of int"}.</li>
925 * </ul>
926 *
927 * @since 1.6
928 */
929 private Object readResolve() throws ObjectStreamException {
930 if (primitiveArray) {
931 return convertFromWrapperToPrimitiveTypes();
932 } else {
933 return this;
934 }
935 }
936
937 private ArrayType convertFromWrapperToPrimitiveTypes() {
938 String cn = getClassName();
939 String tn = getTypeName();
940 String d = getDescription();
941 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
942 if (cn.indexOf((String)typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]) != -1) {
943 cn = cn.replaceFirst(
944 "L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";",
945 (String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]);
946 tn = tn.replaceFirst(
947 "L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";",
948 (String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]);
949 d = d.replaceFirst(
950 (String) typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX],
951 (String) typeDescr[PRIMITIVE_TYPE_NAME_INDEX]);
952 break;
953 }
954 }
955 return new ArrayType(cn, tn, d,
956 dimension, elementType, primitiveArray);
957 }
958
959 /**
960 * Nominate a replacement for this object in the stream before the object
961 * is written.
962 *
963 * @serialData The new serial form of this class defines a new serializable
964 * {@code boolean} field {@code primitiveArray}. In order to guarantee the
965 * interoperability with previous versions of this class the new serial
966 * form must continue to refer to primitive wrapper types even when the
967 * {@code ArrayType} instance describes a primitive type array. So when
968 * {@code primitiveArray} is {@code true} the {@code className},
969 * {@code typeName} and {@code description} serializable fields
970 * are converted into wrapper types before the serialized
971 * {@code ArrayType} instance is written to the stream. The
972 * {@code elementType} field always returns the {@code SimpleType}
973 * corresponding to the primitive wrapper type of the array's
974 * primitive type.
975 * <p>
976 * Therefore the following serializable fields are serialized as follows:
977 * <ul>
978 * <li>if {@code primitiveArray} is {@code true} the {@code className}
979 * field is serialized by replacing the array's component primitive
980 * type by the corresponding array's component primitive wrapper type,
981 * e.g. {@code "[[I"} will be serialized as
982 * {@code "[[Ljava.lang.Integer;"}.</li>
983 * <li>if {@code primitiveArray} is {@code true} the {@code typeName}
984 * field is serialized by replacing the array's component primitive
985 * type by the corresponding array's component primitive wrapper type,
986 * e.g. {@code "[[I"} will be serialized as
987 * {@code "[[Ljava.lang.Integer;"}.</li>
988 * <li>if {@code primitiveArray} is {@code true} the {@code description}
989 * field is serialized by replacing the array's component primitive
990 * type by the corresponding array's component primitive wrapper type,
991 * e.g. {@code "2-dimension array of int"} will be serialized as
992 * {@code "2-dimension array of java.lang.Integer"}.</li>
993 * </ul>
994 *
995 * @since 1.6
996 */
997 private Object writeReplace() throws ObjectStreamException {
998 if (primitiveArray) {
999 return convertFromPrimitiveToWrapperTypes();
1000 } else {
1001 return this;
1002 }
1003 }
1004
1005 private ArrayType convertFromPrimitiveToWrapperTypes() {
1006 String cn = getClassName();
1007 String tn = getTypeName();
1008 String d = getDescription();
1009 for (Object[] typeDescr : PRIMITIVE_ARRAY_TYPES) {
1010 if (cn.indexOf((String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX]) != -1) {
1011 cn = cn.replaceFirst(
1012 (String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX],
1013 "L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";");
1014 tn = tn.replaceFirst(
1015 (String) typeDescr[PRIMITIVE_TYPE_KEY_INDEX],
1016 "L" + typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX] + ";");
1017 d = d.replaceFirst(
1018 (String) typeDescr[PRIMITIVE_TYPE_NAME_INDEX],
1019 (String) typeDescr[PRIMITIVE_WRAPPER_NAME_INDEX]);
1020 break;
1021 }
1022 }
1023 return new ArrayType(cn, tn, d,
1024 dimension, elementType, primitiveArray);
1025 }
1026 }
Save This Page