private ArgumentType getArgumentType (Parameter parameter) { String[] typeTokens = parameter.getType().toString().split("\\."); String type = typeTokens[typeTokens.length - 1]; int arrayDim = 0; for (int i = 0; i < type.length(); i++) { if (type.charAt(i) == '[') arrayDim++; } type = type.replace("[", "").replace("]", ""); if (arrayDim >= 1) { if (arrayDim > 1) return ArgumentType.ObjectArray; ArgumentType arrayType = arrayTypes.get(type); if (arrayType == null) { return ArgumentType.ObjectArray; } return arrayType; } if (plainOldDataTypes.containsKey(type)) return plainOldDataTypes.get(type); if (bufferTypes.containsKey(type)) return bufferTypes.get(type); if (otherTypes.containsKey(type)) return otherTypes.get(type); return ArgumentType.Object; }
private ArgumentType getArgumentType (Parameter parameter) { String[] typeTokens = parameter.getType().toString().split("\\."); String type = typeTokens[typeTokens.length - 1]; int arrayDim = 0; for (int i = 0; i < type.length(); i++) { if (type.charAt(i) == '[') arrayDim++; } type = type.replace("[", "").replace("]", ""); if (arrayDim >= 1) { if (arrayDim > 1) return ArgumentType.ObjectArray; ArgumentType arrayType = arrayTypes.get(type); if (arrayType == null) { return ArgumentType.ObjectArray; } return arrayType; } if (plainOldDataTypes.containsKey(type)) return plainOldDataTypes.get(type); if (bufferTypes.containsKey(type)) return bufferTypes.get(type); if (otherTypes.containsKey(type)) return otherTypes.get(type); return ArgumentType.Object; }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
private String getQualifiedName(Type type) { return context.getFullyQualifiedNameForClassName(type.toString()); } }
private boolean argsMatch(Class<?>[] parameterTypes, List<Parameter> parameters) { if (parameters == null) { return parameterTypes.length == 0; } else if (parameters.size() != parameterTypes.length) { return false; } for (int i = 0; i < parameterTypes.length; i++) { Class<?> paramType = parameterTypes[i]; Parameter param = parameters.get(i); if (!paramType.getSimpleName().equals(param.getType().toString())) { return false; } } return true; }
private boolean argsMatch(Class<?>[] parameterTypes, List<Parameter> parameters) { if (parameters == null) { return parameterTypes.length == 0; } else if (parameters.size() != parameterTypes.length) { return false; } for (int i = 0; i < parameterTypes.length; i++) { Class<?> paramType = parameterTypes[i]; Parameter param = parameters.get(i); if (!paramType.getSimpleName().equals(param.getType().toString())) { return false; } } return true; }
private ArgumentType getArgumentType (Parameter parameter) { String[] typeTokens = parameter.getType().toString().split("\\."); String type = typeTokens[typeTokens.length - 1]; int arrayDim = 0; for (int i = 0; i < type.length(); i++) { if (type.charAt(i) == '[') arrayDim++; } type = type.replace("[", "").replace("]", ""); if (arrayDim >= 1) { if (arrayDim > 1) return ArgumentType.ObjectArray; ArgumentType arrayType = arrayTypes.get(type); if (arrayType == null) { return ArgumentType.ObjectArray; } return arrayType; } if (plainOldDataTypes.containsKey(type)) return plainOldDataTypes.get(type); if (bufferTypes.containsKey(type)) return bufferTypes.get(type); if (otherTypes.containsKey(type)) return otherTypes.get(type); return ArgumentType.Object; }
continue; String paranTypeName = ptype.toString(); int index = paranTypeName.lastIndexOf("."); if (index > 0) {
/** * Process the $event variable passed on v-on. This variable must have a valid cast in front. * * @param expression The currently processed expression * @param nameExpr The variable we are processing * @param parameters The parameters this expression depends on */ private void processEventParameter(Expression expression, NameExpr nameExpr, List<VariableInfo> parameters) { Optional<Node> parentNode = nameExpr.getParentNode(); if (parentNode.isPresent() && parentNode.get() instanceof CastExpr) { CastExpr castExpr = (CastExpr) parentNode.get(); parameters.add(new VariableInfo(castExpr.getType().toString(), "$event")); } else { logger.error( "\"$event\" should always be casted to it's intended type. Example: @click=\"doSomething((Event) $event)\".", expression.toString()); } }
private void getParameterNames(MethodDeclaration methodDeclaration, boolean isInterface) { final EnumSet<Modifier> modifiers = methodDeclaration.getModifiers(); if (isInterface || modifiers.contains(Modifier.PUBLIC)) { String methodName = methodDeclaration.getName().getIdentifier(); List<Parameter> parameters = methodDeclaration.getParameters(); names.className = this.className; List<List<ParameterName>> parameterNames = names.names.computeIfAbsent(methodName, k -> new ArrayList<>(4)); final List<ParameterName> temp = new ArrayList<>(); for (final Parameter parameter : parameters) { ParameterName parameterName = new ParameterName(); String type = parameter.getType().toString(); String name = parameter.getName().getIdentifier(); if (name.contains("[]")) { type = type + "[]"; name = name.replace("[]", ""); } parameterName.type = type; parameterName.name = name; temp.add(parameterName); } parameterNames.add(temp); } } }
@Override public void visit(FieldDeclaration fd, List<EntityField> f) { if (fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Column"))) { Class<?> type = null; switch (fd.getType().toString()) { case "String": type = String.class; break; case "Long": type = Long.class; break; case "Integer": type = Integer.class; break; case "boolean": type = boolean.class; break; } if (type == null) return; f.add(new EntityField( fd.getVariables().get(0).getId().getName(), type, fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Id")))); } } }, entityFields);
public String getKey() { if (declaration instanceof FieldDeclaration) { FieldDeclaration field = (FieldDeclaration) declaration; if (field.getVariables().size() != 1) { throw new RuntimeException( "Multiple fields in a single manual field declaration is not yet supported: " + field.toString()); } return "F:" + field.getVariable(0).getNameAsString(); } else if (declaration instanceof MethodDeclaration) { MethodDeclaration method = (MethodDeclaration) declaration; return "M:" + method.getNameAsString() + ":" + method.getParameters().stream() .map(p -> p.getType().toString()).collect(Collectors.joining(",")); } else if (declaration instanceof ConstructorDeclaration) { ConstructorDeclaration constructor = (ConstructorDeclaration) declaration; return "C:" + constructor.getParameters().stream().map(p -> p.getType().toString()) .collect(Collectors.joining(",")); } throw new RuntimeException( "Unsupported manual member type encountered: " + declaration.getClass().getName()); }
/** * Get the type of an expression from the cast at the beginning. (int) 12 -> 12 of type int (int) * 15 + 5 -> 15 + 5 of type int (float) (12 + 3) -> 12 + 3 of type float ((int) 12) + 3 -> ((int) * 12) + 3 of type Any ((JsArray) myArray).getAt(0) -> ((JsArray) myArray).getAt(0) of type Any * * @param expression The expression to process * @return The modified expression (where cast has been removed if necessary) */ private Expression getTypeFromCast(Expression expression) { if (expression instanceof BinaryExpr) { Expression mostLeft = getLeftmostExpression(expression); if (mostLeft instanceof CastExpr) { CastExpr castExpr = (CastExpr) mostLeft; currentExpressionReturnType = stringTypeToTypeName(castExpr.getType().toString()); BinaryExpr parent = (BinaryExpr) mostLeft.getParentNode().get(); parent.setLeft(castExpr.getExpression()); } } else if (expression instanceof CastExpr) { CastExpr castExpr = (CastExpr) expression; currentExpressionReturnType = stringTypeToTypeName(castExpr.getType().toString()); expression = castExpr.getExpression(); } return expression; }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
/** * Visit the parameter of a Route method. * @param param Parameter of the route method. * @param route The route model that we construct. */ @Override public void visit(Parameter param, ControllerRouteModel route) { List<AnnotationExpr> annos = param.getAnnotations(); if(annos == null || annos.isEmpty()){ LOGGER.warn("[controller]The parameter " + param + "at line " + param.getBeginLine() + " " + "is for a route method but has not been annotated!"); return; } RouteParamModel routeParam = new RouteParamModel(); routeParam.setParamName(String.valueOf(param.getId())); routeParam.setName(routeParam.getParamName()); //by default, will be override if name is specified //Parsed the param (for the annotation) paramVisitor.visit(param,routeParam); if(routeParam.getParamType() == null){ //ignore if the param has not been visited (i.e no annotations) return; } //TODO some cleaning here! routeParam.setValueType(param.getType().toString()); route.addParam(routeParam); }