jdk-sandbox: comparison jdk/src/java.management/share/classes/sun/management/MappedMXBeanType.java

equal deleted inserted replaced

-:ca83b4cae363
+:e37c7eba132f
 /*
-* Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2004, 2015, 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
 import java.io.InvalidObjectException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
-import javax.management.*;
 import javax.management.openmbean.*;
 import static javax.management.openmbean.SimpleType.*;
-import com.sun.management.VMOption;
 /**
 * A mapped mxbean type maps a Java type to an open type.
 * Only the following Java types are mappable
 * (currently required by the platform MXBeans):
 MappedMXBeanType mt = new BasicMXBeanType(c, ot);
 convertedTypes.put(c, mt);
 return mt;
 }
-static synchronized MappedMXBeanType getMappedType(Type t)
+public static synchronized MappedMXBeanType getMappedType(Type t)
 throws OpenDataException {
 MappedMXBeanType mt = convertedTypes.get(t);
 if (mt == null) {
 mt = newMappedType(t);
 }
 MappedMXBeanType mt = getMappedType(t);
 return mt.toOpenTypeData(data);
 }
 // Return the mapped open type
-OpenType<?> getOpenType() {
+public OpenType<?> getOpenType() {
 return openType;
 }
 boolean isBasicType() {
 return isBasicType;
 abstract Type getJavaType();
 // return name of the class or the generic type
 abstract String getName();
-abstract Object toOpenTypeData(Object javaTypeData)
+public abstract Object toOpenTypeData(Object javaTypeData)
 throws OpenDataException;
-abstract Object toJavaTypeData(Object openTypeData)
+public abstract Object toJavaTypeData(Object openTypeData)
 throws OpenDataException, InvalidObjectException;
 // Basic Types - Classes that do not require data conversion
 //               including primitive types and all SimpleType
 //
 String getName() {
 return basicType.getName();
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
 return data;
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 return data;
 }
 }
 String getName() {
 return enumClass.getName();
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
 return ((Enum) data).name();
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 try {
 return Enum.valueOf(enumClass, (String) data);
 } catch (IllegalArgumentException e) {
 String getName() {
 return arrayClass.getName();
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
 // If the base element type is a basic type
 // return the data as no conversion is needed.
 // Primitive types are not converted to wrappers.
 if (baseElementType.isBasicType()) {
 return data;
 }
 return openArray;
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 // If the base element type is a basic type
 // return the data as no conversion is needed.
 if (baseElementType.isBasicType()) {
 String getName() {
 return typeName;
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
 final List<Object> list = (List<Object>) data;
 final Object[] openArray = (Object[])
 Array.newInstance(paramType.getMappedTypeClass(),
 list.size());
 openArray[i++] = paramType.toOpenTypeData(o);
 }
 return openArray;
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 final Object[] openArray = (Object[]) data;
 List<Object> result = new ArrayList<>(openArray.length);
 for (Object o : openArray) {
 String getName() {
 return typeName;
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
 final Map<Object,Object> map = (Map<Object,Object>) data;
 final TabularType tabularType = (TabularType) openType;
 final TabularData table = new TabularDataSupport(tabularType);
 final CompositeType rowType = tabularType.getRowType();
 table.put(row);
 }
 return table;
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 final TabularData td = (TabularData) data;
 Map<Object, Object> result = new HashMap<>();
 // o If FooType is an array, the item type is an array and
 //   its element type is determined as described above.
 //
 static class CompositeDataMXBeanType extends MappedMXBeanType {
 final Class<?> javaClass;
-final boolean isCompositeData;
+boolean isCompositeData = false;
 Method fromMethod = null;
+Method toMethod = null;
 CompositeDataMXBeanType(Class<?> c) throws OpenDataException {
 this.javaClass = c;
 this.mappedTypeClass = COMPOSITE_DATA_CLASS;
 } catch (PrivilegedActionException e) {
 // ignore NoSuchMethodException since we allow classes
 // that has no from method to be embeded in another class.
 }
+// check if a static "toCompositeData" method exists
+try {
+toMethod = AccessController.doPrivileged(new PrivilegedExceptionAction<Method>() {
+public Method run() throws NoSuchMethodException {
+Method m = javaClass.getDeclaredMethod("toCompositeData", javaClass);
+if (m != null
+&& CompositeData.class.isAssignableFrom(m.getReturnType())
+&& Modifier.isStatic(m.getModifiers())) {
+m.setAccessible(true);
+return m;
+} else {
+return null;
+}
+}
+});
+} catch (PrivilegedActionException e) {
+// ignore NoSuchMethodException since we allow classes
+// that has no from method to be embeded in another class.
+}
 if (COMPOSITE_DATA_CLASS.isAssignableFrom(c)) {
 // c implements CompositeData - set openType to null
 // defer generating the CompositeType
 // until the object is constructed
 this.isCompositeData = true;
 this.isCompositeData = false;
 // Make a CompositeData containing all the getters
 final Method[] methods =
 AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
 public Method[] run() {
 return javaClass.getMethods();
 }
 });
 final List<String> names = new ArrayList<>();
 final List<OpenType<?>> types = new ArrayList<>();
 /* Select public methods that look like "T getX()" or "boolean
 isX()", where T is not void and X is not the empty
 string.  Exclude "Class getClass()" inherited from Object.  */
 for (int i = 0; i < methods.length; i++) {
 final Method method = methods[i];
 final String name = method.getName();
 final Type type = method.getGenericReturnType();
 final String rest;
 types.add(toOpenType(type));
 }
 final String[] nameArray = names.toArray(new String[0]);
 openType = new CompositeType(c.getName(),
 c.getName(),
 nameArray, // field names
 nameArray, // field descriptions
 types.toArray(new OpenType<?>[0]));
 }
 }
 Type getJavaType() {
 return javaClass;
 String getName() {
 return javaClass.getName();
 }
-Object toOpenTypeData(Object data) throws OpenDataException {
+public Object toOpenTypeData(Object data) throws OpenDataException {
+if (toMethod != null) {
+try {
+return toMethod.invoke(null, data);
+} catch (IllegalAccessException e) {
+// should never reach here
+throw new AssertionError(e);
+} catch (InvocationTargetException e) {
+final OpenDataException ode
+= new OpenDataException("Failed to invoke "
++ toMethod.getName() + " to convert " + javaClass.getName()
++ " to CompositeData");
+ode.initCause(e);
+throw ode;
+}
+}
 if (data instanceof MemoryUsage) {
 return MemoryUsageCompositeData.toCompositeData((MemoryUsage) data);
 }
 if (data instanceof ThreadInfo) {
 }
 if (data instanceof MemoryNotificationInfo) {
 return MemoryNotifInfoCompositeData.
 toCompositeData((MemoryNotificationInfo) data);
-}
-if (data instanceof VMOption) {
-return VMOptionCompositeData.toCompositeData((VMOption) data);
 }
 if (isCompositeData) {
 // Classes that implement CompositeData
 //
 throw new OpenDataException(javaClass.getName() +
 " is not supported for platform MXBeans");
 }
-Object toJavaTypeData(Object data)
+public Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 if (fromMethod == null) {
 throw new AssertionError("Does not support data conversion");
 }

changeset 30355	e37c7eba132f
parent 27957	24b4e6082f19
child 30655	d83f50188ca9