private static <T> T convertFrom(Object x, OpenType<T> openType) { if (openType.isValue(x)) { T t = OpenMBeanAttributeInfoSupport.<T>cast(x); return t; } return convertFromStrings(x, openType); }
/** * Returns the hash code value for this {@code OpenMBeanParameterInfoSupport} instance. * * <p>The hash code of an {@code OpenMBeanParameterInfoSupport} instance is the sum of the hash * codes of all elements of information used in {@code equals} comparisons (ie: its name, its * <i>open type</i>, its default, min, max and legal values, and its Descriptor). * * <p>This ensures that {@code t1.equals(t2)} implies that {@code t1.hashCode()==t2.hashCode()} * for any two {@code OpenMBeanParameterInfoSupport} instances {@code t1} and {@code t2}, as * required by the general contract of the method {@link Object#hashCode() Object.hashCode()}. * * <p>However, note that another instance of a class implementing the {@code * OpenMBeanParameterInfo} interface may be equal to this {@code OpenMBeanParameterInfoSupport} * instance as defined by {@link #equals(java.lang.Object)}, but may have a different hash code if * it is calculated differently. * * <p>As {@code OpenMBeanParameterInfoSupport} instances are immutable, the hash code for this * instance is calculated once, on the first call to {@code hashCode}, and then the same value is * returned for subsequent calls. * * @return the hash code value for this {@code OpenMBeanParameterInfoSupport} instance */ public int hashCode() { // Calculate the hash code value if it has not yet been done // (ie 1st call to hashCode()) // if (myHashCode == null) myHashCode = OpenMBeanAttributeInfoSupport.hashCode(this); // return always the same hash code for this instance (immutable) // return myHashCode.intValue(); }
/** * Returns a string representation of this {@code OpenMBeanParameterInfoSupport} instance. * * <p>The string representation consists of the name of this class (i.e. {@code * javax.management.openmbean.OpenMBeanParameterInfoSupport}), the string representation of the * name and open type of the described parameter, the string representation of its default, min, * max and legal values and the string representation of its descriptor. * * <p>As {@code OpenMBeanParameterInfoSupport} instances are immutable, the string representation * for this instance is calculated once, on the first call to {@code toString}, and then the same * value is returned for subsequent calls. * * @return a string representation of this {@code OpenMBeanParameterInfoSupport} instance. */ public String toString() { // Calculate the string value if it has not yet been done (ie // 1st call to toString()) // if (myToString == null) myToString = OpenMBeanAttributeInfoSupport.toString(this); // return always the same string representation for this // instance (immutable) // return myToString; }
/* A Descriptor contained an array value encoded as Strings. The Strings must be organized in an array corresponding to the desired array. If the desired array has n dimensions, so must the String array. We will convert element by element from String to desired component type. */ private static <T> T convertFromStringArray(Object x, OpenType<T> openType) { ArrayType<?> arrayType = (ArrayType<?>) openType; OpenType<?> baseType = arrayType.getElementOpenType(); int dim = arrayType.getDimension(); String squareBrackets = "["; for (int i = 1; i < dim; i++) squareBrackets += "["; Class<?> stringArrayClass; Class<?> targetArrayClass; try { stringArrayClass = Class.forName(squareBrackets + "Ljava.lang.String;"); targetArrayClass = Class.forName(squareBrackets + "L" + baseType.safeGetClassName() + ";"); } catch (ClassNotFoundException e) { throw new NoClassDefFoundError(e.toString()); // can't happen } if (!stringArrayClass.isInstance(x)) { final String msg = "Value for " + dim + "-dimensional array of " + baseType.getTypeName() + " must be same type or a String " + "array with same dimensions"; throw new IllegalArgumentException(msg); } OpenType<?> componentOpenType; if (dim == 1) componentOpenType = baseType; else { try { componentOpenType = new ArrayType<T>(dim - 1, baseType); } catch (OpenDataException e) { throw new IllegalArgumentException(e.getMessage(), e); // can't happen } } int n = Array.getLength(x); Object[] targetArray = (Object[]) Array.newInstance(targetArrayClass.getComponentType(), n); for (int i = 0; i < n; i++) { Object stringish = Array.get(x, i); // String or String[] etc Object converted = convertFromStrings(stringish, componentOpenType); Array.set(targetArray, i, converted); } return OpenMBeanAttributeInfoSupport.<T>cast(targetArray); }
/** * Tests whether {@code obj} is a valid value for the parameter described by this {@code * OpenMBeanParameterInfo} instance. * * @param obj the object to be tested. * @return {@code true} if {@code obj} is a valid value for the parameter described by this {@code * OpenMBeanParameterInfo} instance, {@code false} otherwise. */ public boolean isValue(Object obj) { return OpenMBeanAttributeInfoSupport.isValue(this, obj); // compiler bug? should be able to omit class name here // also below in toString and hashCode }