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

equal deleted inserted replaced

-:e08d565262ce
+:a9d059c15b80
 // Suppress unchecked cast warnings at line 442, 523 and 546
 // Suppress unchecked calls at line 235, 284, 380 and 430.
 @SuppressWarnings("unchecked")
 public abstract class MappedMXBeanType {
 private static final WeakHashMap<Type,MappedMXBeanType> convertedTypes =
-new WeakHashMap<Type,MappedMXBeanType>();
+new WeakHashMap<>();
 boolean  isBasicType = false;
-OpenType openType = inProgress;
+OpenType<?> openType = inProgress;
-Class    mappedTypeClass;
+Class<?>    mappedTypeClass;
 static synchronized MappedMXBeanType newMappedType(Type javaType)
 throws OpenDataException {
 MappedMXBeanType mt = null;
 if (javaType instanceof Class) {
-final Class c = (Class) javaType;
+final Class<?> c = (Class<?>) javaType;
 if (c.isEnum()) {
 mt = new EnumMXBeanType(c);
 } else if (c.isArray()) {
 mt = new ArrayMXBeanType(c);
 } else {
 }
 } else if (javaType instanceof ParameterizedType) {
 final ParameterizedType pt = (ParameterizedType) javaType;
 final Type rawType = pt.getRawType();
 if (rawType instanceof Class) {
-final Class rc = (Class) rawType;
+final Class<?> rc = (Class<?>) rawType;
 if (rc == List.class) {
 mt = new ListMXBeanType(pt);
 } else if (rc == Map.class) {
 mt = new MapMXBeanType(pt);
 }
 convertedTypes.put(javaType, mt);
 return mt;
 }
 // basic types do not require data mapping
-static synchronized MappedMXBeanType newBasicType(Class c, OpenType ot)
+static synchronized MappedMXBeanType newBasicType(Class<?> c, OpenType<?> ot)
 throws OpenDataException {
 MappedMXBeanType mt = new BasicMXBeanType(c, ot);
 convertedTypes.put(c, mt);
 return mt;
 }
 }
 return mt;
 }
 // Convert a class to an OpenType
-public static synchronized OpenType toOpenType(Type t)
+public static synchronized OpenType<?> toOpenType(Type t)
 throws OpenDataException {
 MappedMXBeanType mt = getMappedType(t);
 return mt.getOpenType();
 }
 MappedMXBeanType mt = getMappedType(t);
 return mt.toOpenTypeData(data);
 }
 // Return the mapped open type
-OpenType getOpenType() {
+OpenType<?> getOpenType() {
 return openType;
 }
 boolean isBasicType() {
 return isBasicType;
 String getTypeName() {
 return getMappedTypeClass().getName();
 }
 // Return the mapped open type
-Class getMappedTypeClass() {
+Class<?> getMappedTypeClass() {
 return mappedTypeClass;
 }
 abstract Type getJavaType();
 //
 // Data Mapping:
 //   T <-> T (no conversion)
 //
 static class BasicMXBeanType extends MappedMXBeanType {
-final Class basicType;
+final Class<?> basicType;
-BasicMXBeanType(Class c, OpenType openType) {
+BasicMXBeanType(Class<?> c, OpenType<?> openType) {
 this.basicType = c;
 this.openType = openType;
 this.mappedTypeClass = c;
 this.isBasicType = true;
 }
 // Data Mapping:
 //   Enum <-> enum's name
 //
 static class EnumMXBeanType extends MappedMXBeanType {
 final Class enumClass;
-EnumMXBeanType(Class c) {
+EnumMXBeanType(Class<?> c) {
 this.enumClass = c;
 this.openType = STRING;
 this.mappedTypeClass = String.class;
 }
 //
 // Data Mapping:
 //   E[] <-> openTypeData(E)[]
 //
 static class ArrayMXBeanType extends MappedMXBeanType {
-final Class arrayClass;
+final Class<?> arrayClass;
 protected MappedMXBeanType componentType;
 protected MappedMXBeanType baseElementType;
-ArrayMXBeanType(Class c) throws OpenDataException {
+ArrayMXBeanType(Class<?> c) throws OpenDataException {
 this.arrayClass = c;
 this.componentType = getMappedType(c.getComponentType());
 StringBuilder className = new StringBuilder();
-Class et = c;
+Class<?> et = c;
 int dim;
 for (dim = 0; et.isArray(); dim++) {
 className.append('[');
 et = et.getComponentType();
 }
 new OpenDataException("Cannot obtain array class");
 ode.initCause(e);
 throw ode;
 }
-openType = new ArrayType(dim, baseElementType.getOpenType());
+openType = new ArrayType<>(dim, baseElementType.getOpenType());
 }
 protected ArrayMXBeanType() {
 arrayClass = null;
 };
 new OpenDataException("Cannot obtain array class");
 ode.initCause(e);
 throw ode;
 }
-openType = new ArrayType(dim, baseElementType.getOpenType());
+openType = new ArrayType<>(dim, baseElementType.getOpenType());
 }
 Type getJavaType() {
 return gtype;
 }
 if (!(argTypes[0] instanceof Class)) {
 throw new OpenDataException("Element Type for " + pt +
 " not supported");
 }
-final Class et = (Class) argTypes[0];
+final Class<?> et = (Class<?>) argTypes[0];
 if (et.isArray()) {
 throw new OpenDataException("Element Type for " + pt +
 " not supported");
 }
 paramType = getMappedType(et);
 final OpenDataException ode =
 new OpenDataException("Array class not found");
 ode.initCause(e);
 throw ode;
 }
-openType = new ArrayType(1, paramType.getOpenType());
+openType = new ArrayType<>(1, paramType.getOpenType());
 }
 Type getJavaType() {
 return javaType;
 }
 Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 final Object[] openArray = (Object[]) data;
-List<Object> result = new ArrayList<Object>(openArray.length);
+List<Object> result = new ArrayList<>(openArray.length);
 for (Object o : openArray) {
 result.add(paramType.toJavaTypeData(o));
 }
 return result;
 }
 // FIXME: generate typeName for generic
 typeName = "Map<" + keyType.getName() + "," +
 valueType.getName() + ">";
-final OpenType[] mapItemTypes = new OpenType[] {
+final OpenType<?>[] mapItemTypes = new OpenType<?>[] {
 keyType.getOpenType(),
 valueType.getOpenType(),
 };
 final CompositeType rowType =
 new CompositeType(typeName,
 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();
-for (Map.Entry entry : map.entrySet()) {
+for (Map.Entry<Object, Object> entry : map.entrySet()) {
 final Object key = keyType.toOpenTypeData(entry.getKey());
 final Object value = valueType.toOpenTypeData(entry.getValue());
 final CompositeData row =
 new CompositeDataSupport(rowType,
 mapItemNames,
 Object toJavaTypeData(Object data)
 throws OpenDataException, InvalidObjectException {
 final TabularData td = (TabularData) data;
-Map<Object, Object> result = new HashMap<Object, Object>();
+Map<Object, Object> result = new HashMap<>();
 for (CompositeData row : (Collection<CompositeData>) td.values()) {
 Object key = keyType.toJavaTypeData(row.get(KEY));
 Object value = valueType.toJavaTypeData(row.get(VALUE));
 result.put(key, value);
 }
 static class CompositeDataMXBeanType extends MappedMXBeanType {
 final Class<?> javaClass;
 final boolean isCompositeData;
 Method fromMethod = null;
-CompositeDataMXBeanType(Class c) throws OpenDataException {
+CompositeDataMXBeanType(Class<?> c) throws OpenDataException {
 this.javaClass = c;
 this.mappedTypeClass = COMPOSITE_DATA_CLASS;
 // check if a static from method exists
 try {
 AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
 public Method[] run() {
 return javaClass.getMethods();
 }
 });
-final List<String> names = new ArrayList<String>();
+final List<String> names = new ArrayList<>();
-final List<OpenType> types = new ArrayList<OpenType>();
+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 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]));
+types.toArray(new OpenType<?>[0]));
 }
 }
 Type getJavaType() {
 return javaClass;
 //
 // construct a new CompositeDataSupport object
 // so that no other classes are sent over the wire
 CompositeData cd = (CompositeData) data;
 CompositeType ct = cd.getCompositeType();
-String[] itemNames = (String[]) ct.keySet().toArray(new String[0]);
+String[] itemNames = ct.keySet().toArray(new String[0]);
 Object[] itemValues = cd.getAll(itemNames);
 return new CompositeDataSupport(ct, itemNames, itemValues);
 }
 throw new OpenDataException(javaClass.getName() +
 public boolean isValue(Object o) {
 return false;
 }
 private static final long serialVersionUID = -3413063475064374490L;
 }
-private static final OpenType inProgress;
+private static final OpenType<?> inProgress;
 static {
-OpenType t;
+OpenType<?> t;
 try {
 t = new InProgress();
 } catch (OpenDataException e) {
 // Should not reach here
 throw new AssertionError(e);
 VOID,
 };
 static {
 try {
 for (int i = 0; i < simpleTypes.length; i++) {
-final OpenType t = simpleTypes[i];
+final OpenType<?> t = simpleTypes[i];
-Class c;
+Class<?> c;
 try {
 c = Class.forName(t.getClassName(), false,
 String.class.getClassLoader());
 MappedMXBeanType.newBasicType(c, t);
 } catch (ClassNotFoundException e) {
 }
 if (c.getName().startsWith("java.lang.")) {
 try {
 final Field typeField = c.getField("TYPE");
-final Class primitiveType = (Class) typeField.get(null);
+final Class<?> primitiveType = (Class<?>) typeField.get(null);
 MappedMXBeanType.newBasicType(primitiveType, t);
 } catch (NoSuchFieldException e) {
 // OK: must not be a primitive wrapper
 } catch (IllegalAccessException e) {
 // Should not reach here

changeset 11530	a9d059c15b80
parent 5506	202f599c92aa
child 13589	da4cb574f4a6