public void applyFilter() {
String filter = getText();
filter = filter.toLowerCase();
// Replace anything but 0-9, a-z, or : with a space
filter = filter.replaceAll("[^\\x30-\\x39^\\x61-\\x7a^\\x3a]", " ");
filters = Arrays.asList(filter.split(" "));
filterLibraries(category, filters);
contributionListPanel.updateColors();
}
/** sorts the user list and rebuilds the user list from the sorted user vector, */
public void updateList() {
Object[] tmp = users.toArray();
Arrays.sort(tmp);
userList.setListData(tmp);
}
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.
*
* <p>Multidimensional arrays are not supported.
*
* <p>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 ExecutionException) e = e.getCause();
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 EditFocusAdapter(this));
tf.addKeyListener(new CopyKeyAdapter());
}
}
public static class EditFocusAdapter extends FocusAdapter {
private CellEditor editor;
public EditFocusAdapter(CellEditor editor) {
this.editor = editor;
}
@Override
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);
@Override
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();
}
}
@Override
public void keyTyped(KeyEvent e) {
e.consume();
}
}
}
private void grow(int max) {
int sz = line_data.length;
if (sz > max) return;
while (sz < max) sz *= 2;
line_data = Arrays.copyOf(line_data, sz);
}