/** * For method 'signatures' (e:g FromStorageDomain, DirectLun) Parameters should * be mostly copied from the base method (e.g: add). This method does this. */ private void copyParameters(Method childMethod, Method method) { for (Parameter parameter : method.getParameters()) { Parameter newParameter = new Parameter(); //copy from base parameter. Member-involvement-trees not copied on purpose. newParameter.setIn(parameter.isIn()); newParameter.setOut(parameter.isOut()); newParameter.setType(parameter.getType()); newParameter.setName(parameter.getName()); newParameter.setDoc(parameter.getDoc()); newParameter.setSource(parameter.getSource()); newParameter.getAnnotations().addAll(parameter.getAnnotations()); //set the child-method as the declaring method newParameter.setDeclaringMethod(childMethod); childMethod.addParameter(newParameter); } }
public boolean isMandatoryAttributeExists() { for (Parameter parameter : getParameters()) { if (parameter.isMandatory() || !parameter.getMandatoryAttributes().isEmpty()) { return true; } } return false; }
@Override public String toString(boolean protect) { StringBuilder buffer = new StringBuilder(); buffer.append(parameter.getDeclaringMethod().getName()); buffer.append(":"); buffer.append(parameter.getName()); return buffer.toString(); } }
private void generateValidationMethodName(Method method) { Parameter parameter = jaxrsGeneratorUtils.getMainAddParameter(method); javaBuffer.addImports(schemaNames.getXjcTypeReference(parameter.getType()).getImports()); javaBuffer.addLine("public static void validate%s(%s %s) {", javaNames.getJavaClassStyleName(method.getName()), javaNames.getJavaClassStyleName(parameter.getType().getName()), javaNames.getJavaMemberStyleName(parameter.getName())); }
javaBuffer.addLine("if (action!=null"); for (Parameter parameter : signature.getParameters()) { if (parameter.isMandatory()) { assert parameter.getType() instanceof EnumType || parameter.getType() instanceof PrimitiveType; javaBuffer.addLine(" && %s!=null", "action" + isOrGet(parameter.getType()) + javaNames.getJavaClassStyleName(parameter.getName()) + "()"); Iterator<MemberInvolvementTree> iterator = parameter.getMandatoryAttributes().iterator(); while (iterator.hasNext()) { list.add(0, new MemberInvolvementTree(parameter.getName())); String check = getFullAttributeCheck( javaNames.getJavaMemberStyleName(ACTION), if (alternative != null) { list = stackAttributeComponents(alternative); list.add(0, new MemberInvolvementTree(parameter.getName())); check = getFullAttributeCheck( javaNames.getJavaMemberStyleName(ACTION),
@Override public String toString() { StringBuilder buffer = new StringBuilder(); if (declaringMethod != null) { buffer.append(declaringMethod); buffer.append(":"); } buffer.append(getName()); return buffer.toString(); } }
private void handleSignature(Name parentMethodName, Method signature, Name parameterName, Type parameterType) { Parameter parameter = signature.getParameter(parameterName); Iterator<MemberInvolvementTree> iterator = parameter.getMandatoryAttributes().iterator(); if (iterator.hasNext()) {//if there are any mandatory attributes javaBuffer.addDocComment(signature.getName().toString()); javaBuffer.addLine("if (" +javaNames.getJavaMemberStyleName(parameter.getName()) + "!=null"); while (iterator.hasNext()) { MemberInvolvementTree attribute = iterator.next(); List<MemberInvolvementTree> list = stackAttributeComponents(attribute); String attributeCheck = getFullAttributeCheck(javaNames.getJavaMemberStyleName(parameter.getName()), list, Operator.AND, true); if (attribute.getAlternative()!=null) {//'or' expression list = stackAttributeComponents(attribute.getAlternative()); String alternativeCheck = getFullAttributeCheck(javaNames.getJavaMemberStyleName(parameter.getName()), list, Operator.AND, true); String fullCheck = mergeChecks(attributeCheck, alternativeCheck); javaBuffer.addLine(fullCheck); } else { javaBuffer.addLine(attributeCheck); } } javaBuffer.addLine(") {"); javaBuffer.addLine("return " + resourceName.getSimpleName() + ".class.getMethod(\"" + javaNames.getJavaMemberStyleName(parentMethodName) + javaNames.getJavaClassStyleName(signature.getName()) + "\", " + javaNames.getJavaClassStyleName(parameter.getType().getName()) + ".class);"); javaBuffer.addLine("}"); } }
private void generateParameterValidation(Parameter parameter) { Name parameterName = parameter.getName(); String argName = javaNames.getJavaMemberStyleName(parameterName); String tagName = schemaNames.getSchemaTagName(parameterName); List<MemberInvolvementTree> mandatoryAttributes = parameter.getMandatoryAttributes(); if (parameter.isMandatory() || !mandatoryAttributes.isEmpty()) { javaBuffer.addLine("if (%1$s == null) {", argName); javaBuffer.addLine( "throw new ValidationException(\"Parameter '%1$s' is mandatory but was not provided.\");", tagName); javaBuffer.addLine("}"); } for (MemberInvolvementTree attribute : mandatoryAttributes) { List<MemberInvolvementTree> attributeComponents = stackAttributeComponents(attribute); String attributePath = getSchemaPath(attributeComponents); if (attribute.hasAlternative()) { //'OR' scenario generateAlternativesValidation(parameterName, attribute, attributeComponents, attributePath); } else { javaBuffer.addLine( "if (%1$s) {", getFullAttributeCheck(argName, attributeComponents, Operator.OR, false) ); //(TODO: replace line below with invocation of CompletenessAssertor) String fullAttributePath = convertToModelNotation(argName + "." + attributePath); javaBuffer.addLine("throw new ValidationException(\"Parameter '%1$s' is mandatory but was not provided.\");", fullAttributePath); } javaBuffer.addLine("}"); javaBuffer.addLine(); } }
private void analyzeParameter(JavaMethod javaMethod, Method method) { // Create the parameter: Parameter parameter = new Parameter(); analyzeName(javaMethod, parameter); analyzeAnnotations(javaMethod, parameter); analyzeDocumentation(javaMethod, parameter); // Get the direction: if (isAnnotatedWith(javaMethod, ModelAnnotations.IN)) { parameter.setIn(true); } if (isAnnotatedWith(javaMethod, ModelAnnotations.OUT)) { parameter.setOut(true); } // Get the type: assignTypeReference(javaMethod.getReturns(), parameter::setType); // Get the default value: String javaValue = javaMethod.getSourceCode(); if (javaValue != null && !javaValue.isEmpty()) { Expression expression = analyzeExpression(javaValue); parameter.setDefaultValue(expression); } // Add the parameter to the method: parameter.setDeclaringMethod(method); method.addParameter(parameter); }
private void reportIncompatibleParameterTypes(Parameter offending, Parameter existing) { String message = String.format( "The type \"%s\" of parameter \"%s\" isn't compatible with the type \"%s\" of existing parameter \"%s\"", offending.getType(), offending, existing.getType(), existing ); throw new IllegalArgumentException(message); } }
private void writeParameter(Parameter parameter) { writer.writeStartElement("parameter"); writeCommon(parameter); writer.writeElement("in", Boolean.toString(parameter.isIn())); writer.writeElement("out", Boolean.toString(parameter.isIn())); writeTypeRef(parameter.getType()); writer.writeEndElement(); }
assert parameter.getType() instanceof PrimitiveType || parameter.getType() instanceof EnumType; parameter.setMandatory(mandatory); return null; } else { currentNode.setType(getType(parameter.getType(), currentNode.getName()));
public List<Parameter> getMandatoryParameters() { List<Parameter> parameters = new ArrayList<>(); for (Parameter parameter : getParameters()) { if (parameter.isMandatory()) { parameters.add(parameter); } } return parameters; } }
public List<MemberInvolvementTree> getMandatoryAttributes() { List<MemberInvolvementTree> mandatoryAttributes = new ArrayList<>(); for (Parameter parameter : getParameters()) { mandatoryAttributes.addAll(parameter.getMandatoryAttributes()); } return mandatoryAttributes; }
private void analyzeLocatorParameter(JavaParameter javaParameter, Locator locator) { // Create the parameter: Parameter parameter = new Parameter(); analyzeName(javaParameter, parameter); analyzeAnnotations(javaParameter, parameter); analyzeDocumentation(javaParameter, parameter); // Get the type: assignTypeReference(javaParameter.getJavaClass(), parameter::setType); // Add the parameter to the locator: locator.addParameter(parameter); }
private void generateSignatureDetection(Method method) { Set<Method> signatures = baseMethods.get(method); if (mandatoryAttributeExists(signatures)) { javaBuffer.addImport(java.lang.reflect.Method.class); Parameter parameter = jaxrsGeneratorUtils.getMainAddParameter(method); Name parameterName = parameter.getName(); javaBuffer.addImports(schemaNames.getXjcTypeReference(parameter.getType()).getImports()); Name methodName = getSignatureDetectionMethodName(method); javaBuffer.addLine("public static Method %s(%s %s) throws NoSuchMethodException, SecurityException {", javaNames.getJavaMemberStyleName(methodName), javaNames.getJavaClassStyleName(parameter.getType().getName()), javaNames.getJavaMemberStyleName(parameterName)); generateParameterValidation(parameter); CyclicIterator iterator = new CyclicIterator(signatures); while (iterator.hasNext()) { Method signature = iterator.next(); if (!jaxrsHelperGeneratorUtils.isContained(signature, signatures)) { handleSignature(method.getName(), signature, parameterName, parameter.getType()); iterator.remove(); } } closeSignatureDetectionMethod(); } //TODO: in the future fail for this // else { // throw new ValidationException(method.getName() + "'s signatures have 0 mandatory attributes (any signature must have at least 1 mandatory attribute)"); // } }
private void generateActionParameterValidation(Parameter parameter) { Name paramName = parameter.getName(); String propertyName = javaNames.getJavaPropertyStyleName(paramName); String tagName = schemaNames.getSchemaTagName(paramName); if (parameter.isMandatory()) {//a simple parameter being mandatory only happens in 'action's. javaBuffer.addLine("if (action%1$s%2$s() == null) {", isOrGet(parameter.getType()), propertyName); for (MemberInvolvementTree attribute : parameter.getMandatoryAttributes()) { List<MemberInvolvementTree> attributeComponents = stackAttributeComponents(attribute); MemberInvolvementTree component = new MemberInvolvementTree(new Name(parameter.getName())); component.setType(parameter.getType()); attributeComponents.add(0, component); String attributePath = getSchemaPath(attributeComponents);
private boolean isParametersContained(List<Parameter> mandatoryParameters1, List<Parameter> mandatoryParameters2) { if (mandatoryParameters1.isEmpty() && mandatoryParameters2.isEmpty()) { return false; } List<Name> names1 = new ArrayList<>(); List<Name> names2 = new ArrayList<>(); for (Parameter p : mandatoryParameters1) { names1.add(p.getName()); } for (Parameter p : mandatoryParameters2) { names2.add(p.getName()); } return names2.containsAll(names1); }