/** * Precondition: setter must take one parameter, and getter must return * a type, not void */ protected static boolean typesAgree(Method getter, Method setter) { if (getter == null || getter.isVoid() || setter == null) return false; JavaParameter[] parameters = setter.listParametersWithoutReturn(); if (parameters.length != 1) return false; JavaParameter param = parameters[0]; return param.getEType() != null && param.getEType() == getter.getReturnType(); }
/** * Return the parameters in a displayable format. * @see getParmsAsString(Method) */ public static final String getParmsAsString(JavaParameter[] parm) { if(parm.length == 0) { return ""; //$NON-NLS-1$ } StringBuffer buffer = new StringBuffer(); for(int i=0; i<parm.length; i++) { JavaHelpers type = parm[i].getJavaType(); buffer.append(((type == null) ? "null" : type.getJavaName())); //$NON-NLS-1$ buffer.append(COMMA); } return buffer.substring(0, buffer.length() - 2); // since "COMMA" is 2 char long, and the last COMMA isn't needed at the end, return everything up to but excluding the last COMMA }
/** * Return a Parameter with the passed name, or null. */ public JavaParameter getParameter(String parameterName) { List parms = getParameters(); JavaParameter parm; int parmSize = parms.size(); for (int j = 0; j < parmSize; j++) { parm = (JavaParameter) parms.get(j); if (parm.getName().equals(parameterName)) return parm; } return null; }
/** * createJavaParameter - instantiate a Java Parameter based on the passed name and type name (a simple name, NOT A SIGNATURE!!!) * The id for a parameter has to be complex in order to be parsable into class, method, and parm. * It is created by appending the parm name to the method id, with a known separator. * It will look something like "Foo.doSomething(java.lang.Integer-arg0" */ public JavaParameter createJavaParameter(Method parentMethod, String parmName, String parmTypeName) { JavaParameter newParm = getJavaFactory().createJavaParameter(); if (parmName!=null) newParm.setName(parmName); // ((InternalEObject)newParm).eSetID(parentMethod.eID() + C_METHODID_PARMID_DELIMITER + parmName); String classRefString = parmTypeName; newParm.setEType(createJavaClassRef(classRefString)); return newParm; } /**
/** * Verifies that a given method is RMI legal. * This means that their argument and return values must be of valid types * for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException. */ public final void validateLegalRMIMethodArguments(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { vc.terminateIfCancelled(); if (method == null) { return; } JavaParameter[] args = method.listParametersWithoutReturn(); for (int i = 0; i < args.length; i++) { vc.terminateIfCancelled(); if (!ValidationRuleUtility.isLegalRMI_IIOPType(bean, args[i].getJavaType())) { IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2413, IEJBValidationContext.INFO, bean, clazz, method, new String[]{args[i].getQualifiedName()}, this); vc.addMessage(message); } } }
/** * This allows for the retrieval of parameters with the following notation: * parameter: java:/com.ibm.foo#Test.foofoo(-arg0 * */ protected JavaParameter getJavaParameter(String keyValue) { JavaParameter result = null; String parmName; int memberDelimiter = keyValue.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER); int parmDelimiter = keyValue.indexOf(ReflectionAdaptor.C_METHODID_PARMID_DELIMITER, memberDelimiter); parmName = keyValue.substring(parmDelimiter + 1); // getMethod() will find or create a method Method method = this.getJavaMethod(keyValue.substring(parmDelimiter)); if (method != null) { result = method.getParameter(parmName); if (result == null) { JavaParameter tempParameter = createJavaParameter(); tempParameter.setName(parmName); // ((InternalEObject)tempParameter).eSetID(keyValue); // tempParameter.eSetUUID((UUID) null); method.getParameters().add(tempParameter); result = tempParameter; } } return result; } /* (non-Javadoc)
JavaHelpers javaHelpers = inputParams[i].getJavaType(); w.write(getFullyQualifiedName(javaHelpers)); w.write(" "); String paramName = getClassName(inputParams[i].getQualifiedName()); w.write(getUnusedName(paramName)); String paramName = getClassName(inputParams[i].getQualifiedName()); w.write(getUnusedName(paramName));
public boolean isMethodType(EnterpriseBean bean, JavaClass clazz, Method method, List[] methodsExtendedLists) { if(method == null) { return false; } if(method.getName().startsWith(IMethodAndFieldConstants.METHODNAME_EQUALS)) { JavaParameter[] parm = method.listParametersWithoutReturn(); if(parm.length == 1) { try { JavaHelpers object = ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVA_LANG_OBJECT, bean); JavaHelpers parmType = parm[0].getJavaType(); if(object.equals(parmType)) { return true; } } catch(InvalidInputException e) { return false; } } } return false; }
/** * Get method name string of form: * methodName(class name of arg1,class name of arg2,...) * Creation date: (8/24/00 1:21:10 PM) * @return String * @param m Method */ private static String methodKey(Method m) { StringBuffer result = new StringBuffer(m.getName()); result.append("("); //$NON-NLS-1$ java.util.List args = m.getParameters(); JavaParameter arg; for (int i = 0; i < args.size(); i++) { arg = (JavaParameter) args.get(i); result.append(((JavaHelpers) arg.getEType()).getJavaName()); result.append(","); //$NON-NLS-1$ } result.append(")"); //$NON-NLS-1$ return result.toString(); } public Object primRefValue(EObject feature) {
public boolean isMethodType(EnterpriseBean bean, JavaClass clazz, Method method, List[] methodsExtendedLists) { if(method == null) { return false; } if(method.getName().equals(IMethodAndFieldConstants.METHODNAME_SETENTITYCONTEXT)) { JavaParameter[] parm = method.listParametersWithoutReturn(); if(parm.length == 1) { try { JavaHelpers entityContext = ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVAX_EJB_ENTITYCONTEXT, bean); JavaHelpers parmType = parm[0].getJavaType(); if(entityContext.equals(parmType)) { return true; } } catch(InvalidInputException e) { return false; } } } return false; }
protected Method getMethod(String name, List parameterTypes, List methodList) { boolean found = false; Method method; for (int i = 0; i < methodList.size(); i++) { method = (Method) methodList.get(i); JavaParameter[] params; if (method.getName().equals(name)) { params = method.listParametersWithoutReturn(); if (params.length == parameterTypes.size()) { found = true; //Maybe; we need more info for (int j = 0; j < params.length; j++) { //if any one of the parameters doesn't match then flip back to false JavaHelpers jh = (JavaHelpers) params[j].getEType(); if (!jh.getQualifiedName().equals(parameterTypes.get(j))) { found = false; break; } // end if params equal } // end compare all params if (found) //short circuit out of this loop and return the winner return method; } // end compare lengths } // end compare names } // end loop through all methodList return null; }
public boolean isMethodType(EnterpriseBean bean, JavaClass clazz, Method method, List[] methodsExtendedLists) { if(method == null) { return false; } if(method.getName().equals(IMethodAndFieldConstants.METHODNAME_ONMESSAGE)) { JavaParameter[] parms = method.listParametersWithoutReturn(); if(parms.length == 1) { try { JavaHelpers jmsMessage = ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVAX_JMS_MESSAGE, bean); JavaHelpers parmType = parms[0].getJavaType(); if(jmsMessage.equals(parmType)) { return true; } } catch(InvalidInputException e) { return false; } } } return false; }
/** * Return a String with the the method name and its parameters. e.g. <code> setFirstName(java.lang.String) <//code> . * */ public String getMethodElementSignature() { StringBuffer sb = new StringBuffer(75); sb.append(getName()); sb.append("("); List params = getParameters(); JavaParameter param; int parmSize = params.size(); int commaTest = 0; for (int j = 0; j < parmSize; j++) { if (j > commaTest) { sb.append(","); } param = (JavaParameter) params.get(j); //FB if (param.isReturn()) { //FB commaTest ++; //FB continue; //FB } sb.append(((JavaHelpers) param.getEType()).getQualifiedName()); } sb.append(")"); return sb.toString(); }
public final JavaHelpers getOverExposedLocalType(EnterpriseBean bean, JavaClass clazz, Method method) { if((isRemote() & IEJBType.REMOTE) == IEJBType.REMOTE) { // need to check that the method doesn't expose any of the local types of the bean JavaParameter[] parms = method.listParametersWithoutReturn(); if(parms != null) { for(int i=0; i<parms.length; i++) { JavaParameter parm = parms[i]; if(ValidationRuleUtility.isLocalType(bean, parm.getJavaType())) { return parm.getJavaType(); } } } // Now check the return type JavaHelpers parm = method.getReturnType(); if(ValidationRuleUtility.isLocalType(bean, parm)) { return parm; } return null; } return null; }
public static final boolean usesLocalTypes(EnterpriseBean bean, Method method) { if((bean == null) || (method == null)) { return false; } JavaParameter[] parms = method.listParametersWithoutReturn(); if(parms != null) { for(int i=0; i<parms.length; i++) { JavaParameter parm = parms[i]; if(isLocalType(bean, parm.getJavaType())) { return true; } } } // Now check the return type if(isLocalType(bean, method.getReturnType())) { return true; } return false; } }
/** * Return true only if all the parameters for @aMethod * matches the names in the list of parameters. */ public boolean matchesParams(Method aMethod) { if (aMethod == null) return false; List params = getMethodParams(); JavaParameter[] methodParams = aMethod.listParametersWithoutReturn(); if (params.size() != methodParams.length) return false; for (int i = 0; i < methodParams.length; i++){ String parameterType = ((JavaHelpers)methodParams[i].getEType()).getQualifiedName(); if (!params.get(i).equals(parameterType)) return false; } return true; } /**
JavaParameter parm = parms[i]; try { if(isAssignableFromCollection(parm.getJavaType(), bean)) { return true;
JavaHelpers parm = ((JavaHelpers)params[j].getEType()); JavaHelpers type = parameterTypes[j]; if(!isSameType(parm, type)) {