Refine search
private void addBeanInfoToClassIntrospectionData( Map<Object, Object> introspData, Class<?> clazz, Map<MethodSignature, List<Method>> accessibleMethods) throws IntrospectionException { BeanInfo beanInfo = Introspector.getBeanInfo(clazz); List<PropertyDescriptor> pdas = getPropertyDescriptors(beanInfo, clazz); int pdasLength = pdas.size(); IdentityHashMap<Method, Void> argTypesUsedByIndexerPropReaders = null; for (int i = mdsSize - 1; i >= 0; --i) { final Method method = getMatchingAccessibleMethod(mds.get(i).getMethod(), accessibleMethods); if (method != null && isAllowedToExpose(method)) { decision.setDefaults(method); if (propDesc != null && (decision.getReplaceExistingProperty() || !(introspData.get(propDesc.getName()) instanceof FastPropertyDescriptor))) { addPropertyDescriptorToClassIntrospectionData( introspData, propDesc, clazz, accessibleMethods);
MethodDescriptor[] introspectorMDArray = beanInfo.getMethodDescriptors(); List<MethodDescriptor> introspectionMDs = introspectorMDArray != null && introspectorMDArray.length != 0 ? Arrays.asList(introspectorMDArray) : Collections.<MethodDescriptor>emptyList(); = new ArrayList<MethodDescriptor>(introspectionMDs.size() + 16); for (MethodDescriptor introspectorMD : introspectionMDs) { Method introspectorM = introspectorMD.getMethod(); introspectionMDs.add(new MethodDescriptor(method));
BeanInfo info = Introspector.getBeanInfo(obj.getClass()); PropertyDescriptor[] propertyDescriptors = info.getPropertyDescriptors(); MethodDescriptor[] methodDescriptors = info.getMethodDescriptors(); HashMap<String, Method> methodMap = new HashMap<String, Method>(); for (MethodDescriptor methodDescriptor : methodDescriptors) { methodMap.put( methodDescriptor.getName().toLowerCase(Locale.ENGLISH), methodDescriptor.getMethod()); if (skipSet.contains(pd.getName())) { continue; "Skipping property (no read method): " + prefix + pd.getName() + " " + pd.getPropertyType()); continue;
StringBuffer optionsBuff = new StringBuffer(); for (MethodDescriptor m_Method : m_Methods) { String name = m_Method.getDisplayName(); Method meth = m_Method.getMethod(); OptionMetadata o = meth.getAnnotation(OptionMetadata.class); Method getter = m_Properties[i].getReadMethod(); Method setter = m_Properties[i].getWriteMethod(); if (getter == null || setter == null) { continue; if (m_Properties[sortedPropOrderings[i]].isHidden() || m_Properties[sortedPropOrderings[i]].isExpert()) { continue; String mname = m_Method.getDisplayName(); Method meth = m_Method.getMethod(); if ( mname.equals( tipName ) ) { if ( meth.getReturnType().equals( String.class ) ) {
Class<?> superClass = beanClass.getSuperclass(); while (superClass != null) { Introspector.flushFromCaches(superClass); superClass = superClass.getSuperclass(); BeanInfo info = Introspector.getBeanInfo(beanClass); beanDescriptor = info.getBeanDescriptor(); if (beanDescriptor != null) { Class<?> customizerClass = getCustomizerClass(); beanDescriptor = new BeanDescriptor(beanClass, getCustomizerClass()); for (PropertyDescriptor pd : info.getPropertyDescriptors()) { properties.put(pd.getName(), pd); for (EventSetDescriptor esd : info.getEventSetDescriptors()) { events.put(esd.getName(), esd); for (MethodDescriptor md : info.getMethodDescriptors()) { methods.put(md.getName(), md);
public synchronized MethodDescriptor[] getMethodDescriptors() { if (_mds != null) return _mds; PropertyDescriptor[] pds = getPropertyDescriptors(); List<MethodDescriptor> descs = new ArrayList<MethodDescriptor>(); for (int i = 0; i < pds.length; i++) { Method write = pds[i].getWriteMethod(); Method read = pds[i].getReadMethod(); if (read != null && write != null) { descs.add(new MethodDescriptor(write)); descs.add(new MethodDescriptor(read)); } } _mds = (MethodDescriptor[]) descs. toArray(new MethodDescriptor[descs.size()]); return _mds; }
private static Method findMethod(Class<?> targetType, String methodName, Class<?>[] argTypes) throws IntrospectionException { BeanInfo beanInfo = Introspector.getBeanInfo(targetType); if (beanInfo != null) { for(MethodDescriptor methodDesc: beanInfo.getMethodDescriptors()) { Method method = methodDesc.getMethod(); Class<?>[] parameterTypes = method.getParameterTypes(); if (methodName.equals(method.getName()) && argTypes.length == parameterTypes.length) { boolean matchedArgTypes = true; for (int i = 0; i < argTypes.length; i++) { if (getWrapperIfPrimitive(argTypes[i]) != parameterTypes[i]) { matchedArgTypes = false; break; } } if (matchedArgTypes) { return method; } } } } return null; }
public static Method getReadMethodObject(FeatureDescriptor _featureDescriptor) { if (_featureDescriptor instanceof MethodDescriptor) { MethodDescriptor md = (MethodDescriptor) _featureDescriptor; return md.getMethod(); } if (_featureDescriptor instanceof EventSetDescriptor) { EventSetDescriptor md = (EventSetDescriptor) _featureDescriptor; Method em = md.getGetListenerMethod();// md.getGetListenerMethod(); if (em != null) return em; return null;// md.getGetListenerMethod(); } if (_featureDescriptor instanceof PropertyDescriptor) { PropertyDescriptor md = (PropertyDescriptor) _featureDescriptor; Method m = md.getReadMethod(); if (m != null) return m; Method m2 = md.getWriteMethod(); if (m2 != null) return m2; } return null; }
/** * Return the global info (if it exists) for the supplied clusterer * * @param clusterer the clusterer to get the global info for * @return the global info (synopsis) for the clusterer * @throws Exception if there is a problem reflecting on the clusterer */ protected static String getGlobalInfo(Clusterer clusterer) throws Exception { BeanInfo bi = Introspector.getBeanInfo(clusterer.getClass()); MethodDescriptor[] methods; methods = bi.getMethodDescriptors(); Object[] args = {}; String result = "\nSynopsis for " + clusterer.getClass().getName() + ":\n\n"; for (MethodDescriptor method : methods) { String name = method.getDisplayName(); Method meth = method.getMethod(); if (name.equals("globalInfo")) { String globalInfo = (String) (meth.invoke(clusterer, args)); result += globalInfo; break; } } return result; }
Introspector.getBeanInfo(chart.getClass()).getMethodDescriptors(); HashMap<String, Method> chartMethodMap = new HashMap<String, Method>(); for (MethodDescriptor methodDescriptor : methodDescriptors) { chartMethodMap.put( methodDescriptor.getName().toLowerCase(Locale.ENGLISH), methodDescriptor.getMethod()); Introspector.getBeanInfo(chart.getStyler().getClass()).getMethodDescriptors(); HashMap<String, Method> stylerMethodMap = new HashMap<String, Method>(); for (MethodDescriptor methodDescriptor : methodDescriptors) { stylerMethodMap.put( methodDescriptor.getName().toLowerCase(Locale.ENGLISH), methodDescriptor.getMethod());
@Override public MethodDescriptor[] getMethodDescriptors() { MethodDescriptor[] methodDescriptors = this.beanInfo .getMethodDescriptors(); // just ensuring the that order stays the same between executions Map<String, MethodDescriptor> signatures = new TreeMap<String, MethodDescriptor>( Collections.reverseOrder()); for (MethodDescriptor methodDescriptor : methodDescriptors) { String signature = methodDescriptor.getMethod().toGenericString(); if (signatures.put(signature, methodDescriptor) != null) { assert false; } } return signatures.values().toArray( new MethodDescriptor[signatures.size()]); }
protected void doCollectOperations(Class<?> clazz, BeanInfo beanInfo) { for (MethodDescriptor methodInfo : beanInfo.getMethodDescriptors()) { if (methodInfo.isHidden()) { continue; } Descriptor descriptor = doGetDescriptor(methodInfo, "operation"); String name = methodInfo.getName(); Method method = methodInfo.getMethod(); ParameterDescriptor[] parameters = methodInfo.getParameterDescriptors(); boolean hasParameters = parameters != null && parameters.length > 0; Class<?> returnType = method.getReturnType(); boolean returnValue = returnType != null && !void.class.equals(returnType); if ((name.startsWith("get") && hasParameters && returnValue) || (name.startsWith("is") && !hasParameters && boolean.class.equals(returnType))) { descriptor.setField("role", "getter"); } else if (methodInfo.getName().startsWith("set") && void.class.equals(returnType) && hasParameters && parameters.length == 1) { // doFixAttribute(clazz, methodInfo.getName()); descriptor.setField("role", "setter"); } else { descriptor.setField("role", "operation"); } ModelMBeanOperationInfo operationInfo = new ModelMBeanOperationInfo(methodInfo.getShortDescription(), methodInfo.getMethod(), descriptor); operationsInfo.put(operationInfo.getName(), operationInfo); } }
private List<Method> findCandidateWriteMethods(MethodDescriptor[] methodDescriptors) { List<Method> matches = new ArrayList<>(); for (MethodDescriptor methodDescriptor : methodDescriptors) { Method method = methodDescriptor.getMethod(); if (isCandidateWriteMethod(method)) { matches.add(method); } } // Sort non-void returning write methods to guard against the ill effects of // non-deterministic sorting of methods returned from Class#getDeclaredMethods // under JDK 7. See http://bugs.sun.com/view_bug.do?bug_id=7023180 matches.sort((m1, m2) -> m2.toString().compareTo(m1.toString())); return matches; }
try { BeanInfo beanInfo = getBeanInfo(contextClass); methodDescriptors = beanInfo.getMethodDescriptors(); Class<?> declaringClass = md.getMethod().getDeclaringClass(); !md.isHidden() && (!specifiedClassOnly || declaringClass == contextClass)) {
protected DelegatorMethod stubDelegatorMethod(MethodDescriptor mdescr) { Class retType = mdescr.getMethod().getReturnType(); // now add parameter(s) Class[] pts = mdescr.getMethod().getParameterTypes(); String[] pns = Naming.paramNames(pts, mdescr.getParameterDescriptors()); String body = null; if (retType != Void.TYPE) { body = "return null;"; } org.netbeans.modules.visualweb.insync.java.MethodInfo info = new org.netbeans.modules.visualweb.insync.java.MethodInfo(mdescr.getName(), retType, Modifier.PUBLIC, pns, pts, body, null); return adapterClass.addDelegatorMethod(info); }
@Override public Map<String, MethodDescriptor> call() throws Exception { BeanInfo beanInfo = getBeanInfo(beanClass); MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors(); Map<String, MethodDescriptor> map = CollectionUtil.createHashMap(methodDescriptors.length); for (MethodDescriptor methodDescriptor : methodDescriptors) { map.put(methodDescriptor.getName(), methodDescriptor); } return map; } });
/** * Wire up the delegation for this event to the handler method, inserting the methods and * statements as needed. * * @param delegate name of delegate, pass null to use a tmp name & set later */ protected void insertEntry() { Class[] pTypes = descriptor.getMethod().getParameterTypes(); String[] pNames = Naming.paramNames(pTypes, descriptor.getParameterDescriptors()); boolean noreturn = false; if (descriptor.getMethod().getReturnType().getName().equals("void")) { noreturn = true; } set.getDelegatorMethod(descriptor).addDelegateStatement(name, pNames, noreturn); }
/** * Works around a bug in java.beans.Introspector, where sub-interfaces * do not return their parent's methods, in the method descriptor array. */ protected MethodDescriptor[] addMissingContextMethodDescriptors( Method[] methods, MethodDescriptor[] methodDescriptors) { List<Method> methodNames = new ArrayList<Method>(methodDescriptors.length); Vector<MethodDescriptor> mds = new Vector<MethodDescriptor>(methods.length); for (int i=0; i<methodDescriptors.length; i++) { methodNames.add(methodDescriptors[i].getMethod()); mds.add(methodDescriptors[i]); } for (int i=0; i<methods.length; i++) { if (!methodNames.contains(methods[i])) { mds.add(new MethodDescriptor(methods[i])); } } methodDescriptors = new MethodDescriptor[mds.size()]; mds.copyInto(methodDescriptors); return methodDescriptors; }
/** * Get the name of this event * * @return The name of this event. */ public String getName() { return descriptor.getName(); }