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 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; }
private Expression serialize(AnnotationNode an) { MapExpression map = new MapExpression(); for (String key : an.getMembers().keySet()) { map.addMapEntryExpression(new ConstantExpression(key), serialize(an.getMember(key))); } List<Expression> l = new ArrayList<Expression>(2); l.add(new ClassExpression(an.getClassNode())); l.add(map); return new ArrayExpression(ClassHelper.OBJECT_TYPE, l); } }
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 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; }
public boolean memberHasValue(AnnotationNode node, String name, Object value) { final Expression member = node.getMember(name); return member instanceof ConstantExpression && ((ConstantExpression) member).getValue().equals(value); }
@Deprecated public List<ClassNode> getClassList(AnnotationNode anno, String name) { List<ClassNode> list = new ArrayList<ClassNode>(); Expression expr = anno.getMember(name); if (expr instanceof ListExpression) { final ListExpression listExpression = (ListExpression) expr; list = getTypeList(listExpression); } else if (expr instanceof ClassExpression) { ClassNode cn = expr.getType(); if (cn != null) list.add(cn); } return list; }
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; }
private static String lookupLogFieldName(AnnotationNode logAnnotation) { Expression member = logAnnotation.getMember("value"); if (member != null && member.getText() != null) { return member.getText(); } else { return "log"; } }
private static String lookupCategoryName(AnnotationNode logAnnotation) { Expression member = logAnnotation.getMember("category"); if (member != null && member.getText() != null) { return member.getText(); } return DEFAULT_CATEGORY_NAME; }
private static void addGrabResolverAsStaticInitIfNeeded(ClassNode grapeClassNode, AnnotationNode node, List<Statement> grabResolverInitializers, Map<String, Object> grabResolverMap) { if ((node.getMember("initClass") == null) || (node.getMember("initClass") == ConstantExpression.TRUE)) { MapExpression resolverArgs = new MapExpression(); for (Map.Entry<String, Object> next : grabResolverMap.entrySet()) { resolverArgs.addMapEntryExpression(constX(next.getKey()), constX(next.getValue())); } grabResolverInitializers.add(stmt(callX(grapeClassNode, "addResolver", args(resolverArgs)))); } }
@Deprecated public static List<String> getMemberList(AnnotationNode anno, String name) { List<String> list; Expression expr = anno.getMember(name); if (expr instanceof ListExpression) { final ListExpression listExpression = (ListExpression) expr; list = getValueStringList(listExpression); } else { list = tokenize(getMemberStringValue(anno, name)); } return list; }
public void visit(ASTNode[] nodes, final SourceUnit source) { if (nodes.length != 2 || !(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) { throw new RuntimeException("Internal error: expecting [AnnotationNode, AnnotatedNode] but got: " + Arrays.asList(nodes)); } AnnotatedNode parent = (AnnotatedNode) nodes[1]; File f = new File("temp/log.txt"); try { ResourceGroovyMethods.append(f, parent.getClass().getSimpleName() + " " + parent.getAnnotations().get(0).getMember("value").getText() + " "); } catch (IOException e) { e.printStackTrace(); } } }
private static AutoCloneStyle getStyle(AnnotationNode node, String name) { final Expression member = node.getMember(name); if (member instanceof PropertyExpression) { PropertyExpression prop = (PropertyExpression) member; Expression oe = prop.getObjectExpression(); if (oe instanceof ClassExpression) { ClassExpression ce = (ClassExpression) oe; if (ce.getType().getName().equals("groovy.transform.AutoCloneStyle")) { return AutoCloneStyle.valueOf(prop.getPropertyAsString()); } } } return null; }
private static AnnotationCollectorMode getMode(AnnotationNode node) { final Expression member = node.getMember("mode"); if (member instanceof PropertyExpression) { PropertyExpression prop = (PropertyExpression) member; Expression oe = prop.getObjectExpression(); if (oe instanceof ClassExpression) { ClassExpression ce = (ClassExpression) oe; if (ce.getType().getName().equals("groovy.transform.AnnotationCollectorMode")) { return AnnotationCollectorMode.valueOf(prop.getPropertyAsString()); } } } return null; }
@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); }
public static List<String> getMemberStringList(AnnotationNode anno, String name) { Expression expr = anno.getMember(name); if (expr == null) { return null; } if (expr instanceof ListExpression) { final ListExpression listExpression = (ListExpression) expr; if (isUndefinedMarkerList(listExpression)) { return null; } return getValueStringList(listExpression); } return tokenize(getMemberStringValue(anno, name)); }
private void changeBaseScriptTypeFromPackageOrImport(final SourceUnit source, final AnnotatedNode parent, final AnnotationNode node) { Expression value = node.getMember("value"); if (!(value instanceof ClassExpression)) { addError("Annotation " + MY_TYPE_NAME + " member 'value' should be a class literal.", value); return; } List<ClassNode> classes = source.getAST().getClasses(); for (ClassNode classNode : classes) { if (classNode.isScriptBody()) { changeBaseScriptType(parent, classNode, value.getType()); } } }