/** * Calls all public methods declared in the class corresponding to the given object. Does not * include methods from superclasses. * * @param object object to call the public methods on * @param comparator method comparator, allows running the methods in a specific order * @return list of methods invoked, including the parameters used for calling them */ private static List<MethodInvocation> callPublicMethodsInOrder( Object object, Comparator<Method> comparator) { try { List<MethodInvocation> invocations = new ArrayList<>(); Method[] methods = object.getClass().getDeclaredMethods(); if (comparator != null) Arrays.sort(methods, comparator); for (Method method : methods) { if (Modifier.isStatic(method.getModifiers()) || !Modifier.isPublic(method.getModifiers())) continue; Object[] params = new Object[method.getParameterTypes().length]; for (int i = 0; i < method.getParameterTypes().length; i++) { params[i] = instantiateType(method.getParameterTypes()[i]); } method.invoke(object, params); invocations.add(new MethodInvocation(method.getName(), params)); } return invocations; } catch (Exception ex) { ex.printStackTrace(); assertTrue( "Error calling public methods on object " + object + " (" + object.getClass().getSimpleName() + ")", false); return new ArrayList<>(); } }
/** * Copy from the copy method in StructUtil. Did not want to drag that code in. maybe this actually * should go to struct. * * @param from * @param to * @param excludes * @return * @throws Exception */ public static <T extends struct> T xcopy(struct from, T to, String... excludes) throws Exception { Arrays.sort(excludes); for (Field f : from.fields()) { if (Arrays.binarySearch(excludes, f.getName()) >= 0) continue; Object o = f.get(from); if (o == null) continue; Field tof = to.getField(f.getName()); if (tof != null) try { tof.set(to, Converter.cnv(tof.getGenericType(), o)); } catch (Exception e) { System.out.println( "Failed to convert " + f.getName() + " from " + from.getClass() + " to " + to.getClass() + " value " + o + " exception " + e); } } return to; }
// // Return the methods of an interface in a deterministic // order. Class.getMethods() does not do us this favor. // private Method[] sortMethods(Class iface) throws Exception { Method[] raw = iface.getMethods(); int count = raw.length; Method[] cooked = new Method[count]; MethodSortable[] sortables = new MethodSortable[count]; for (int i = 0; i < count; i++) { sortables[i] = new MethodSortable(raw[i]); } Arrays.sort(sortables); for (int i = 0; i < count; i++) { cooked[i] = sortables[i].getMethod(); } return cooked; }
// debug print the list of methods which have disappeared from the SQL interface private void printVanishedMethodList(HashSet<String> vanishedMethodList) { int count = vanishedMethodList.size(); if (count == 0) { return; } println("--------------- VANISHED METHODS ------------------"); println("--"); String[] result = new String[count]; vanishedMethodList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
// debug print the list of methods which throw SQLFeatureNotSupportedException private void printUnsupportedList(HashSet<String> unsupportedList) { int count = unsupportedList.size(); if (count == 0) { return; } println("--------------- UNSUPPORTED METHODS ------------------"); println("--"); String[] result = new String[count]; unsupportedList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
// Debug print the list of method failures which we don't understand private void printNotUnderstoodList(HashSet<String> notUnderstoodList) { int count = notUnderstoodList.size(); if (count == 0) { return; } println("\n\n"); println("--------------- NOT UNDERSTOOD METHODS ------------------"); println("--"); String[] result = new String[count]; notUnderstoodList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
public void applyString(String string) { if (string == null) return; StringTokenizer st = new StringTokenizer(string, ":"); while (st.hasMoreTokens()) { String t = st.nextToken().trim(); int i = t.indexOf('='); String name; String value; if (i >= 0) { name = t.substring(0, i).toLowerCase(Locale.US); value = t.substring(i + 1); } else if (t.startsWith("+")) { name = t.substring(1); value = "true"; } else if (t.startsWith("-")) { name = t.substring(1); value = "false"; } else if (t.endsWith("+")) { name = t.substring(0, t.length() - 1); value = "true"; } else if (t.endsWith("-")) { name = t.substring(0, t.length() - 1); value = "false"; } else { throw new IllegalArgumentException("Missing '=' for argument: " + t); } name = name.trim(); value = value.trim(); Prop p = PROPS.get(name); if (p == null) throw new IllegalArgumentException("Unknown argument: " + name); try { p.field.set(this, parseValue(value, p)); } catch (IllegalAccessException e) { throw new IllegalArgumentException(e); } } filecount = Math.max(0, filecount); Arrays.sort(histogram); }
/** Calculates a MD5 digest of the class. */ public String getDigest() { try { if (_className == null || "".equals(_className)) return ""; DynamicClassLoader loader = (DynamicClassLoader) Thread.currentThread().getContextClassLoader(); ClassLoader tmpLoader = loader.getNewTempClassLoader(); Class cl = Class.forName(_className, false, tmpLoader); if (cl == null) return ""; MessageDigest digest = MessageDigest.getInstance("MD5"); addDigest(digest, cl.getName()); addDigest(digest, cl.getModifiers()); Class superClass = cl.getSuperclass(); if (superClass != null) addDigest(digest, superClass.getName()); Class[] interfaces = cl.getInterfaces(); for (int i = 0; i < interfaces.length; i++) addDigest(digest, interfaces[i].getName()); Field[] fields = cl.getDeclaredFields(); Arrays.sort(fields, new FieldComparator()); if (_checkFields) { for (Field field : fields) { if (Modifier.isPrivate(field.getModifiers()) && !_checkPrivate) continue; if (Modifier.isProtected(field.getModifiers()) && !_checkProtected) continue; addDigest(digest, field.getName()); addDigest(digest, field.getModifiers()); addDigest(digest, field.getType().getName()); addDigest(digest, field.getAnnotations()); } } Method[] methods = cl.getDeclaredMethods(); Arrays.sort(methods, new MethodComparator()); for (int i = 0; i < methods.length; i++) { Method method = methods[i]; if (Modifier.isPrivate(method.getModifiers()) && !_checkPrivate) continue; if (Modifier.isProtected(method.getModifiers()) && !_checkProtected) continue; if (Modifier.isStatic(method.getModifiers()) && !_checkStatic) continue; addDigest(digest, method.getName()); addDigest(digest, method.getModifiers()); addDigest(digest, method.getName()); Class[] param = method.getParameterTypes(); for (int j = 0; j < param.length; j++) addDigest(digest, param[j].getName()); addDigest(digest, method.getReturnType().getName()); Class[] exn = method.getExceptionTypes(); for (int j = 0; j < exn.length; j++) addDigest(digest, exn[j].getName()); addDigest(digest, method.getAnnotations()); } byte[] digestBytes = new byte[256]; int len = digest.digest(digestBytes, 0, digestBytes.length); return digestToBase64(digestBytes, len); } catch (Exception e) { log.log(Level.FINER, e.toString(), e); return ""; } }
/** * Standard constructor. * * @param type Type that you are going to be creating and editor for. * @param readOnly Set to true to create a read-only customizer. */ public DynamicCustomizer(Class type, boolean readOnly) { super(new GridBagLayout()); _readOnly = readOnly; _type = type; LabelFieldGBC gbc = new LabelFieldGBC(); try { BeanInfo info = Introspector.getBeanInfo(type); // Set up pretty display stuff. setBorder(BorderFactory.createTitledBorder(info.getBeanDescriptor().getDisplayName())); setToolTipText(info.getBeanDescriptor().getShortDescription()); // Get the properties and sort them. PropertyDescriptor[] props = info.getPropertyDescriptors(); Arrays.sort(props, new PropertyComparator()); for (int i = 0; i < props.length; i++) { // Ignore the "class" property, if it is provided. if (props[i].getName().equals("class")) continue; // Create a label for the field. JLabel label = new JLabel(props[i].getDisplayName() + ":"); // Lookup the editor. PropertyEditor editor = getEditorForProperty(props[i]); // Add a listener to the editor so we know when to update // the bean's fields. editor.addPropertyChangeListener(_eListener); // XXX What we need to do right here is provide a component // that makes use of the "paintable" capability of the editor. Component comp = editor.getCustomEditor(); if (comp == null) { comp = new JLabel("<No editor available.>"); ((JLabel) comp).setBorder(BorderFactory.createEtchedBorder()); } // See if it is a read-only property. If so, then just // display it. if (_readOnly || props[i].getWriteMethod() == null) { comp.setEnabled(false); } // Setup the accellerator key. label.setLabelFor(comp); label.setDisplayedMnemonic(label.getText().charAt(0)); // Set the tool tip text, if any. String tip = props[i].getShortDescription(); if (tip != null) { label.setToolTipText(tip); if (comp instanceof JComponent) { ((JComponent) comp).setToolTipText(tip); } } // Add the label and fields. add(label, gbc.forLabel()); add(comp, gbc.forField()); // Set the mappings between editor and property, etc. for // quick lookup later. _prop2Editor.put(props[i], editor); _editor2Prop.put(editor, props[i]); } // Filler... add(new JLabel(), gbc.forLastLabel()); } catch (Exception ex) { ex.printStackTrace(); } }