@Override public String toString() { Stack<MemberInvolvementTree> stack = new Stack<>(); stack.add(this); while(stack.peek().hasParent()) { stack.add(stack.peek().getParent()); } StringBuilder builder = new StringBuilder(); while (!stack.isEmpty()) { builder.append(stack.pop().getName()).append("."); } return builder.toString(); }
/** * Removes the provided node from either the tree it exists in, or, * if this node is a root - from the parent parameter. */ private void removeTree(MemberInvolvementTree tree, List<Parameter> parameters, MethodExpression expression) { if (tree.hasParent()) { tree.cutSelf(); } else { //to restore the original order. Stack<Name> stack = new Stack<>(); stackExpressionElements(stack, expression); //find the relevant parameter. Parameter parameter = getParameter(stack.pop(), parameters); parameter.removeMemeberInvolvementTree(tree.getName()); } }
private List<Name> toNames(List<MemberInvolvementTree> attributes) { List<Name> names = new ArrayList<>(); for (MemberInvolvementTree attribute : attributes) { names.add(attribute.getAlternative()==null ? attribute.shallowToString() : combineAlternatives(attribute)); } return names; }
if (currentNode.getType()==null) { currentNode.setType(getType(parameter.getType(), currentNode.getName())); MemberInvolvementTree nextNode = currentNode.getNode(name); if (nextNode==null) { nextNode = new MemberInvolvementTree(name, currentNode); currentNode.getNodes().add(nextNode); if (nextNode.getType()==null) { nextNode.setType(getType(currentNode.getType(), nextNode.getName())); currentNode.setMandatory(mandatory); return currentNode;
private String getAttributePath(List<MemberInvolvementTree> list, String paramName, Operator operator) { StringBuilder attributePath = new StringBuilder(); for (int i=0; i<list.size(); i++) { MemberInvolvementTree current = list.get(i); attributePath.append(isOrGet(current.getType())).append(javaNames.getJavaClassStyleName(current.getName())).append("()"); if (current.isCollection()) { Name name = ((ListType)current.getType()).getElementType().getName(); String getterName = javaNames.getJavaClassStyleName(name) + "s"; if (i==list.size()-1) { //the last element of the expression is a collection StringBuilder soFar = new StringBuilder(paramName).append(attributePath).append(".get").append(getterName).append("()"); if (operator==Operator.AND) { attributePath.append("!=null && ").append(soFar).append("!=null && "); attributePath.append(soFar).append(".size() > 0"); } else { attributePath.append("==null || ").append(soFar).append("==null || "); attributePath.append(soFar).append(".size() == 0"); } } else { attributePath.append(".get").append(getterName).append("().get(0)"); } } } return attributePath.toString(); }
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); if (attribute.hasAlternative()) { //'OR' scenario List<MemberInvolvementTree> alternativeAttributeComponents = stackAttributeComponents(attribute.getAlternative()); alternativeAttributeComponents.add(0, component); String condition1 = "if ( (" + getFullAttributeCheck(javaNames.getJavaMemberStyleName(ACTION), attributeComponents, Operator.OR, false) + ")";
/** * Find the member-involvement-tree with the provided name and return it. * If no such tree exist, create it and add it to the Parameter object, * then return it. */ private MemberInvolvementTree getMemberTree(Parameter parameter, Name name) { for (MemberInvolvementTree tree : parameter.getMemberInvolvementTrees()) { if (tree.getName().equals(name)) { return tree; } } //if none found, create a new one, add it to the Parameter and return it MemberInvolvementTree tree = new MemberInvolvementTree(name); parameter.getMemberInvolvementTrees().add(tree); return tree; }
/** * Remove tree with provided root name from member-involvement-trees list. */ public void removeMemeberInvolvementTree(Name name) { memberInvolvementTrees.removeIf(s -> s.getName().equals(name)); }
@Override public MemberInvolvementTree next() { while (!stack.isEmpty()) { MemberInvolvementTree current = stack.pop(); if (!visited.contains(current)) { visited.add(current); if (current.isLeaf()) { return current; } } for (MemberInvolvementTree child : current.getNodes()) { if (!visited.contains(child)) { stack.push(child); } } } return null; } }
list.add(0, new MemberInvolvementTree(parameter.getName())); String check = getFullAttributeCheck( javaNames.getJavaMemberStyleName(ACTION), MemberInvolvementTree alternative = attribute.getAlternative(); if (alternative != null) { list = stackAttributeComponents(alternative); list.add(0, new MemberInvolvementTree(parameter.getName())); check = getFullAttributeCheck( javaNames.getJavaMemberStyleName(ACTION),
private void generateAlternativesValidation(Name parameterName, MemberInvolvementTree attribute, List<MemberInvolvementTree> attributeComponents, String attributePath) { List<MemberInvolvementTree> alternativeAttributeComponents = stackAttributeComponents(attribute.getAlternative()); String condition1 = "if ( (" + getFullAttributeCheck(javaNames.getJavaMemberStyleName(parameterName), attributeComponents, Operator.OR, false) + ")"; String condition2 = "(" + getFullAttributeCheck(javaNames.getJavaMemberStyleName(parameterName), alternativeAttributeComponents, Operator.OR, false) + ") ) {"; javaBuffer.addLine(condition1 + " && " + condition2); String fullAttributePath1 = convertToModelNotation(parameterName + "." + attributePath); String fullAttributePath2 = convertToModelNotation(parameterName + "." + getSchemaPath(alternativeAttributeComponents)); javaBuffer.addLine( "throw new ValidationException(\"Parameters '%1$s' or '%2$s' are mandatory but both were not provided.\");", fullAttributePath1, fullAttributePath2 ); }
public MemberInvolvementTree getNode(Name name) { for (MemberInvolvementTree node : nodes) { if (node.getName().equals(name)) { return node; } } return null; }
private Name combineAlternatives(MemberInvolvementTree attribute) { Name name1 = attribute.shallowToString(); Name name2 = attribute.getAlternative().shallowToString(); if (name1.compareTo(name2) < 0) { return names.concatenate(name1, name2); } else { return names.concatenate(name2, name1); } } }
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("}"); } }
public Name shallowToString() { Stack<Name> stack = new Stack<>(); MemberInvolvementTree memberInvolvementTree = this; stack.push(memberInvolvementTree.getName()); while (memberInvolvementTree.hasParent()) { memberInvolvementTree = memberInvolvementTree.getParent(); stack.push(memberInvolvementTree.getName()); } Name name = new Name(); while (!stack.isEmpty()) { name.addWords(stack.pop().getWords()); } return name; }
public MemberInvolvementTree getMemberInvolvemnetTree(Name name) { for (MemberInvolvementTree tree : memberInvolvementTrees) { if (tree.getName().equals(name)) { return tree; } } return null; } public boolean isMandatory() {