/*
* Copyright (c) 2004, 2006, 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
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.tools.jconsole.inspector;
import java.awt.event.*;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import javax.management.*;
import javax.management.openmbean.*;
import javax.swing.*;
import javax.swing.text.*;
import java.util.*;
public class Utils {
private Utils() {
}
private static Set<Integer> tableNavigationKeys =
new HashSet<Integer>(Arrays.asList(new Integer[] {
KeyEvent.VK_TAB, KeyEvent.VK_ENTER,
KeyEvent.VK_HOME, KeyEvent.VK_END,
KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT,
KeyEvent.VK_UP, KeyEvent.VK_DOWN,
KeyEvent.VK_PAGE_UP, KeyEvent.VK_PAGE_DOWN}));
private static final Set<Class<?>> primitiveWrappers =
new HashSet<Class<?>>(Arrays.asList(new Class<?>[] {
Byte.class, Short.class, Integer.class, Long.class,
Float.class, Double.class, Character.class, Boolean.class}));
private static final Set<Class<?>> primitives = new HashSet<Class<?>>();
private static final Map<String, Class<?>> primitiveMap =
new HashMap<String, Class<?>>();
private static final Map<String, Class<?>> primitiveToWrapper =
new HashMap<String, Class<?>>();
private static final Set<String> editableTypes = new HashSet<String>();
private static final Set<Class<?>> extraEditableClasses =
new HashSet<Class<?>>(Arrays.asList(new Class<?>[] {
BigDecimal.class, BigInteger.class, Number.class,
String.class, ObjectName.class}));
private static final Set<String> numericalTypes = new HashSet<String>();
private static final Set<String> extraNumericalTypes =
new HashSet<String>(Arrays.asList(new String[] {
BigDecimal.class.getName(), BigInteger.class.getName(),
Number.class.getName()}));
private static final Set<String> booleanTypes =
new HashSet<String>(Arrays.asList(new String[] {
Boolean.TYPE.getName(), Boolean.class.getName()}));
static {
// compute primitives/primitiveMap/primitiveToWrapper
for (Class<?> c : primitiveWrappers) {
try {
Field f = c.getField("TYPE");
Class<?> p = (Class<?>) f.get(null);
primitives.add(p);
primitiveMap.put(p.getName(), p);
primitiveToWrapper.put(p.getName(), c);
} catch (Exception e) {
throw new AssertionError(e);
}
}
// compute editableTypes
for (Class<?> c : primitives) {
editableTypes.add(c.getName());
}
for (Class<?> c : primitiveWrappers) {
editableTypes.add(c.getName());
}
for (Class<?> c : extraEditableClasses) {
editableTypes.add(c.getName());
}
// compute numericalTypes
for (Class<?> c : primitives) {
String name = c.getName();
if (!name.equals(Boolean.TYPE.getName())) {
numericalTypes.add(name);
}
}
for (Class<?> c : primitiveWrappers) {
String name = c.getName();
if (!name.equals(Boolean.class.getName())) {
numericalTypes.add(name);
}
}
}
/**
* This method returns the class matching the name className.
* It's used to cater for the primitive types.
*/
public static Class<?> getClass(String className)
throws ClassNotFoundException {
Class<?> c;
if ((c = primitiveMap.get(className)) != null)
return c;
return Class.forName(className);
}
/**
* Check if the given collection is a uniform collection of the given type.
*/
public static boolean isUniformCollection(Collection<?> c, Class<?> e) {
if (e == null) {
throw new IllegalArgumentException("Null reference type");
}
if (c == null) {
throw new IllegalArgumentException("Null collection");
}
if (c.isEmpty()) {
return false;
}
for (Object o : c) {
if (o == null || !e.isAssignableFrom(o.getClass())) {
return false;
}
}
return true;
}
/**
* Check if the given element denotes a supported array-friendly data
* structure, i.e. a data structure jconsole can render as an array.
*/
public static boolean canBeRenderedAsArray(Object elem) {
if (isSupportedArray(elem)) return true;
if (elem instanceof Collection) {
Collection<?> c = (Collection<?>) elem;
if (c.isEmpty()) {
// Empty collections of any Java type are not handled as arrays
//
return false;
} else {
// - Collections of CompositeData/TabularData are not handled
// as arrays
// - Collections of other Java types are handled as arrays
//
return !isUniformCollection(c, CompositeData.class) &&
!isUniformCollection(c, TabularData.class);
}
}
if (elem instanceof Map) {
return !(elem instanceof TabularData);
}
return false;
}
/**
* Check if the given element is an array.
*
* Multidimensional arrays are not supported.
*
* Non-empty 1-dimensional arrays of CompositeData
* and TabularData are not handled as arrays but as
* tabular data.
*/
public static boolean isSupportedArray(Object elem) {
if (elem == null || !elem.getClass().isArray()) {
return false;
}
Class<?> ct = elem.getClass().getComponentType();
if (ct.isArray()) {
return false;
}
if (Array.getLength(elem) > 0 &&
(CompositeData.class.isAssignableFrom(ct) ||
TabularData.class.isAssignableFrom(ct))) {
return false;
}
return true;
}
/**
* This method provides a readable classname if it's an array,
* i.e. either the classname of the component type for arrays
* of java reference types or the name of the primitive type
* for arrays of java primitive types. Otherwise, it returns null.
*/
public static String getArrayClassName(String name) {
String className = null;
if (name.startsWith("[")) {
int index = name.lastIndexOf("[");
className = name.substring(index, name.length());
if (className.startsWith("[L")) {
className = className.substring(2, className.length() - 1);
} else {
try {
Class<?> c = Class.forName(className);
className = c.getComponentType().getName();
} catch (ClassNotFoundException e) {
// Should not happen
throw new IllegalArgumentException(
"Bad class name " + name, e);
}
}
}
return className;
}
/**
* This methods provides a readable classname. If the supplied name
* parameter denotes an array this method returns either the classname
* of the component type for arrays of java reference types or the name
* of the primitive type for arrays of java primitive types followed by
* n-times "[]" where 'n' denotes the arity of the array. Otherwise, if
* the supplied name doesn't denote an array it returns the same classname.
*/
public static String getReadableClassName(String name) {
String className = getArrayClassName(name);
if (className == null) return name;
int index = name.lastIndexOf("[");
StringBuilder brackets = new StringBuilder(className);
for (int i = 0; i <= index; i++) {
brackets.append("[]");
}
return brackets.toString();
}
/**
* This method tells whether the type is editable
* (means can be created with a String or not)
*/
public static boolean isEditableType(String type) {
return editableTypes.contains(type);
}
/**
* This method inserts a default value for the standard java types,
* else it inserts the text name of the expected class type.
* It acts to give a clue as to the input type.
*/
public static String getDefaultValue(String type) {
if (numericalTypes.contains(type) ||
extraNumericalTypes.contains(type)) {
return "0";
}
if (booleanTypes.contains(type)) {
return "true";
}
type = getReadableClassName(type);
int i = type.lastIndexOf('.');
if (i > 0) {
return type.substring(i + 1, type.length());
} else {
return type;
}
}
/**
* Try to create a Java object using a one-string-param constructor.
*/
public static Object newStringConstructor(String type, String param)
throws Exception {
Constructor c = Utils.getClass(type).getConstructor(String.class);
try {
return c.newInstance(param);
} catch (InvocationTargetException e) {
Throwable t = e.getTargetException();
if (t instanceof Exception) {
throw (Exception) t;
} else {
throw e;
}
}
}
/**
* Try to convert a string value into a numerical value.
*/
private static Number createNumberFromStringValue(String value)
throws NumberFormatException {
final String suffix = value.substring(value.length() - 1);
if ("L".equalsIgnoreCase(suffix)) {
return Long.valueOf(value.substring(0, value.length() - 1));
}
if ("F".equalsIgnoreCase(suffix)) {
return Float.valueOf(value.substring(0, value.length() - 1));
}
if ("D".equalsIgnoreCase(suffix)) {
return Double.valueOf(value.substring(0, value.length() - 1));
}
try {
return Integer.valueOf(value);
} catch (NumberFormatException e) {
// OK: Ignore exception...
}
try {
return Long.valueOf(value);
} catch (NumberFormatException e1) {
// OK: Ignore exception...
}
try {
return Double.valueOf(value);
} catch (NumberFormatException e2) {
// OK: Ignore exception...
}
throw new NumberFormatException("Cannot convert string value '" +
value + "' into a numerical value");
}
/**
* This method attempts to create an object of the given "type"
* using the "value" parameter.
* e.g. calling createObjectFromString("java.lang.Integer", "10")
* will return an Integer object initialized to 10.
*/
public static Object createObjectFromString(String type, String value)
throws Exception {
Object result;
if (primitiveToWrapper.containsKey(type)) {
if (type.equals(Character.TYPE.getName())) {
result = new Character(value.charAt(0));
} else {
result = newStringConstructor(
((Class<?>) primitiveToWrapper.get(type)).getName(),
value);
}
} else if (type.equals(Character.class.getName())) {
result = new Character(value.charAt(0));
} else if (Number.class.isAssignableFrom(Utils.getClass(type))) {
result = createNumberFromStringValue(value);
} else if (value == null || value.toString().equals("null")) {
// hack for null value
result = null;
} else {
// try to create a Java object using
// the one-string-param constructor
result = newStringConstructor(type, value);
}
return result;
}
/**
* This method is responsible for converting the inputs given by the user
* into a useful object array for passing into a parameter array.
*/
public static Object[] getParameters(XTextField[] inputs, String[] params)
throws Exception {
Object result[] = new Object[inputs.length];
Object userInput;
for (int i = 0; i < inputs.length; i++) {
userInput = inputs[i].getValue();
// if it's already a complex object, use the value
// else try to instantiate with string constructor
if (userInput instanceof XObject) {
result[i] = ((XObject) userInput).getObject();
} else {
result[i] = createObjectFromString(params[i].toString(),
(String) userInput);
}
}
return result;
}
/**
* If the exception is wrapped, unwrap it.
*/
public static Throwable getActualException(Throwable e) {
if (e instanceof MBeanException ||
e instanceof RuntimeMBeanException ||
e instanceof RuntimeOperationsException ||
e instanceof ReflectionException) {
Throwable t = e.getCause();
if (t != null) return t;
}
return e;
}
@SuppressWarnings("serial")
public static class ReadOnlyTableCellEditor
extends DefaultCellEditor {
public ReadOnlyTableCellEditor(JTextField tf) {
super(tf);
tf.addFocusListener(new Utils.EditFocusAdapter(this));
tf.addKeyListener(new Utils.CopyKeyAdapter());
}
}
public static class EditFocusAdapter extends FocusAdapter {
private CellEditor editor;
public EditFocusAdapter(CellEditor editor) {
this.editor = editor;
}
public void focusLost(FocusEvent e) {
editor.stopCellEditing();
}
};
public static class CopyKeyAdapter extends KeyAdapter {
private static final String defaultEditorKitCopyActionName =
DefaultEditorKit.copyAction;
private static final String transferHandlerCopyActionName =
(String) TransferHandler.getCopyAction().getValue(Action.NAME);
public void keyPressed(KeyEvent e) {
// Accept "copy" key strokes
KeyStroke ks = KeyStroke.getKeyStroke(
e.getKeyCode(), e.getModifiers());
JComponent comp = (JComponent) e.getSource();
for (int i = 0; i < 3; i++) {
InputMap im = comp.getInputMap(i);
Object key = im.get(ks);
if (defaultEditorKitCopyActionName.equals(key) ||
transferHandlerCopyActionName.equals(key)) {
return;
}
}
// Accept JTable navigation key strokes
if (!tableNavigationKeys.contains(e.getKeyCode())) {
e.consume();
}
}
public void keyTyped(KeyEvent e) {
e.consume();
}
}
}