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 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 t = new ArrayType(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 t1 = new ArrayType(1, SimpleType.STRING);
ArrayType t2 = new ArrayType(1, t1);
ArrayType t3 = new ArrayType(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 - the dimension of arrays described by this ArrayType instance; must be greater than or equal to 1.

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

Throws:

IllegalArgumentException - if {@code dimension} is not a positive integer.

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

 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;
}

Constructs a unidimensional {@code ArrayType} instance for the supplied {@code SimpleType}.

This constructor supports the creation of arrays of primitive types when {@code primitiveArray} is {@code 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 t = new ArrayType(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 - the {@code SimpleType} of the element values contained in the arrays described by this {@code ArrayType} instance.

primitiveArray - {@code true} when this array describes primitive arrays.

Throws:

IllegalArgumentException - if {@code dimension} is not a positive integer.

OpenDataException - if {@code primitiveArray} is {@code true} and {@code elementType} is not a valid {@code SimpleType} for a primitive type.

since: 1.6 -

 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;
}

 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;
}

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.

 public static ArrayType<E> getArrayType(OpenType<E> elementType) throws OpenDataException 
{
        return new ArrayType< E[] >(1, elementType);
}

Create an {@code 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 t1 = ArrayType.getArrayType(SimpleType.STRING);
ArrayType t2 = ArrayType.getArrayType(t1);
ArrayType 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

 public int getDimension() 
{
        return dimension;
}

Returns the dimension of arrays described by this ArrayType instance.

 public OpenType<?> getElementOpenType() 
{
        return elementType;
}

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

 public static 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
        }
}

Create an {@code 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 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

 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;
}

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

 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 key used to identify the element type in arrays - e.g. "Z" for boolean, "C" for char etc...

 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 type name corresponding to the given wrapper class. e.g. "boolean" for "Boolean", "char" for "Character" etc...

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

 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()));
}

 public boolean isPrimitiveArray() 
{
        return primitiveArray;
}

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

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

 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;
}

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 {@code TabularData} interface or the {@code 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.

 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;
}

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.