private static boolean isNull(Expression exp) { if (exp instanceof ConstantExpression){ return ((ConstantExpression) exp).getValue()==null; } else { return false; } }
private static Number safeNumber(ConstantExpression constX) { Object value = constX.getValue(); if (value instanceof Number) return (Number) value; return null; }
private String selectNameConstraint(Expression nameExpr, String constraint1, String constraint2) { if (!(nameExpr instanceof ConstantExpression)) // dynamically generated name return constraint1; String method = (String)((ConstantExpression) nameExpr).getValue(); // NOTE: we cannot tell from the AST if a method (or property) name is defined using // slashy string syntax ("/somePattern/"); hence, we consider any name // that isn't a valid Java identifier a pattern. While this isn't entirely // safe (the JVM allows almost all characters in method names), it should // work out well in practice because it's very unlikely that a // collaborator has a method name that is not a valid Java identifier. return AstUtil.isJavaIdentifier(method) ? constraint1 : constraint2; }
public void visitConstantExpression(ConstantExpression expression) { getParameters().add(expression.getValue()); buffer.append("?"); }
private void checkStringExceedingMaximumLength(ConstantExpression expression) { Object value = expression.getValue(); if (value instanceof String) { String s = (String) value; if (s.length() > 65535) { addError("String too long. The given string is " + s.length() + " Unicode code units long, but only a maximum of 65535 is allowed.", expression); } } }
private void checkForAutoDownload(AnnotationNode node) { Object val = node.getMember(AUTO_DOWNLOAD_SETTING); if (!(val instanceof ConstantExpression)) return; Object autoDownloadValue = ((ConstantExpression)val).getValue(); if (!(autoDownloadValue instanceof Boolean)) return; autoDownload = (Boolean) autoDownloadValue; }
public Expression asConstantString() { StringBuilder buffer = new StringBuilder(); for (ConstantExpression expression : strings) { Object value = expression.getValue(); if (value != null) { buffer.append(value); } } return new ConstantExpression(buffer.toString()); } }
private void checkForClassLoader(AnnotationNode node) { Object val = node.getMember("systemClassLoader"); if (!(val instanceof ConstantExpression)) return; Object systemClassLoaderObject = ((ConstantExpression)val).getValue(); if (!(systemClassLoaderObject instanceof Boolean)) return; Boolean systemClassLoader = (Boolean) systemClassLoaderObject; if (systemClassLoader) loader = ClassLoader.getSystemClassLoader(); }
private void checkForDisableChecksums(AnnotationNode node) { Object val = node.getMember(DISABLE_CHECKSUMS_SETTING); if (!(val instanceof ConstantExpression)) return; Object disableChecksumsValue = ((ConstantExpression)val).getValue(); if (!(disableChecksumsValue instanceof Boolean)) return; disableChecksums = (Boolean) disableChecksumsValue; }
public Object getMemberValue(AnnotationNode node, String name) { final Expression member = node.getMember(name); if (member instanceof ConstantExpression) return ((ConstantExpression) member).getValue(); return null; }
private static List<String> getValueStringList(ListExpression listExpression) { List<String> list = new ArrayList<String>(); for (Expression itemExpr : listExpression.getExpressions()) { if (itemExpr instanceof ConstantExpression) { Object value = ((ConstantExpression) itemExpr).getValue(); if (value != null) list.add(value.toString()); } } return list; }
public boolean memberHasValue(AnnotationNode node, String name, Object value) { final Expression member = node.getMember(name); return member instanceof ConstantExpression && ((ConstantExpression) member).getValue().equals(value); }
private void checkForInitContextClassLoader(AnnotationNode node) { Object val = node.getMember("initContextClassLoader"); if (!(val instanceof ConstantExpression)) return; Object initContextClassLoaderObject = ((ConstantExpression)val).getValue(); if (!(initContextClassLoaderObject instanceof Boolean)) return; initContextClassLoader = (Boolean) initContextClassLoaderObject; }
private static Character tryCharConstant(final Expression expr) { if (expr instanceof ConstantExpression) { ConstantExpression ce = (ConstantExpression) expr; if (ClassHelper.STRING_TYPE.equals(ce.getType())) { String val = (String) ce.getValue(); if (val!=null && val.length()==1) { return val.charAt(0); } } } return null; }
private static boolean isNewMethodStyle(MethodCallExpression mce) { final Expression obj = mce.getObjectExpression(); final Expression meth = mce.getMethod(); return (obj instanceof ClassExpression && meth instanceof ConstantExpression && ((ConstantExpression) meth).getValue().equals("new")); }
public static String getMemberStringValue(AnnotationNode node, String name, String defaultValue) { final Expression member = node.getMember(name); if (member instanceof ConstantExpression) { Object result = ((ConstantExpression) member).getValue(); if (result instanceof String && isUndefined((String) result)) result = null; if (result != null) return result.toString(); } return defaultValue; }
@Override @SuppressWarnings("unchecked") public void visitAnnotations(AnnotatedNode node) { for (AnnotationNode an : node.getAnnotations()) { ClassNode cn = an.getClassNode(); // this comparison should be good enough, and also works in phase conversion if (cn.getNameWithoutPackage().equals(Inspect.class.getSimpleName())) { ConstantExpression name = (ConstantExpression)an.getMember("value"); if (name == null || !(name.getValue() instanceof String)) throw new AstInspectorException("@Inspect must have a String argument"); addNode(markedNodes, (String)name.getValue(), node); break; } } super.visitAnnotations(node); }
private static boolean isUndefinedMarkerList(ListExpression listExpression) { if (listExpression.getExpressions().size() != 1) return false; Expression itemExpr = listExpression.getExpression(0); if (itemExpr == null) return false; if (itemExpr instanceof ConstantExpression) { Object value = ((ConstantExpression) itemExpr).getValue(); if (value instanceof String && isUndefined((String)value)) return true; } else if (itemExpr instanceof ClassExpression && isUndefined(itemExpr.getType())) { return true; } return false; }
public void pushDynamicName(Expression name) { if (name instanceof ConstantExpression) { ConstantExpression ce = (ConstantExpression) name; Object value = ce.getValue(); if (value instanceof String) { pushConstant(ce); return; } } new CastExpression(ClassHelper.STRING_TYPE, name).visit(controller.getAcg()); }