public static MapExpression mapX(List<MapEntryExpression> expressions) { return new MapExpression(expressions); }
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 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)))); } }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
private static void createNoArgConstructor(ClassNode cNode, int modifiers) { Statement body = stmt(ctorX(ClassNode.THIS, args(new MapExpression()))); ConstructorNode consNode = new ConstructorNode(modifiers, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); markAsGenerated(cNode, consNode); cNode.addConstructor(consNode); }
private void callGrabAsStaticInitIfNeeded(ClassNode classNode, ClassNode grapeClassNode, List<Map<String,Object>> grabMapsInit, List<Map<String, Object>> grabExcludeMaps) { List<Statement> grabInitializers = new ArrayList<Statement>(); MapExpression basicArgs = new MapExpression(); if (autoDownload != null) { basicArgs.addMapEntryExpression(constX(AUTO_DOWNLOAD_SETTING), constX(autoDownload)); for (Map<String, Object> map : grabExcludeMaps) { Set<Map.Entry<String, Object>> entries = map.entrySet(); MapExpression inner = new MapExpression(); for (Map.Entry<String, Object> entry : entries) { inner.addMapEntryExpression(constX(entry.getKey()), constX(entry.getValue())); MapExpression dependencyArg = new MapExpression(); for (String s : GRAB_REQUIRED) { dependencyArg.addMapEntryExpression(constX(s), constX(grabMap.get(s)));
/** * Typically only used for map constructors I think? */ protected Expression mapExpression(AST mapNode) { List expressions = new ArrayList(); AST elist = mapNode.getFirstChild(); if (elist != null) { // totally empty in the case of [:] assertNodeType(ELIST, elist); for (AST node = elist.getFirstChild(); node != null; node = node.getNextSibling()) { switch (node.getType()) { case LABELED_ARG: case SPREAD_MAP_ARG: break; // legal cases case SPREAD_ARG: assertNodeType(SPREAD_MAP_ARG, node); break; // helpful error default: assertNodeType(LABELED_ARG, node); break; // helpful error } expressions.add(mapEntryExpression(node)); } } MapExpression mapExpression = new MapExpression(expressions); configureAST(mapExpression, mapNode); return mapExpression; }
expressionList.removeAll(argumentList); checkDuplicateNamedParams(elist, expressionList); MapExpression mapExpression = new MapExpression(expressionList); configureAST(mapExpression, elist); argumentList.add(0, mapExpression);
@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { boolean namedArgumentListExpr = expr instanceof NamedArgumentListExpression; MapExpression conversion = namedArgumentListExpr ? new NamedArgumentListExpression( (List) convertAll(expr.getMapEntryExpressions())) : new MapExpression( (List) convertAll(expr.getMapEntryExpressions())); conversion.setSourcePosition(expr); result = namedArgumentListExpr ? recordNa(conversion) : record(conversion); }
@Override public boolean validateProperties(AbstractASTTransformation xform, BlockStatement body, ClassNode cNode, List<PropertyNode> props) { if (xform instanceof MapConstructorASTTransformation) { body.addStatement(ifS(equalsNullX(varX("args")), assignS(varX("args"), new MapExpression()))); body.addStatement(stmt(callX(SELF_TYPE, "checkPropNames", args("this", "args")))); } return super.validateProperties(xform, body, cNode, props); }
@Override public boolean validateProperties(AbstractASTTransformation xform, BlockStatement body, ClassNode cNode, List<PropertyNode> props) { if (xform instanceof MapConstructorASTTransformation) { body.addStatement(ifS(equalsNullX(varX("args")), assignS(varX("args"), new MapExpression()))); body.addStatement(stmt(callX(IMMUTABLE_XFORM_TYPE, "checkPropNames", args("this", "args")))); } return super.validateProperties(xform, body, cNode, props); }
private boolean processDelegateParam(MethodNode mNode, Parameter mapParam, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { if (isInnerClass(fromParam.getType())) { if (mNode.isStatic()) { addError("Error during " + MY_TYPE_NAME + " processing. Delegate type '" + fromParam.getType().getNameWithoutPackage() + "' is an inner class which is not supported.", mNode); return false; } } Set<String> names = new HashSet<String>(); List<PropertyNode> props = getAllProperties(names, fromParam.getType(), true, false, false, true, false, true); for (String next : names) { if (hasDuplicates(mNode, propNames, next)) return false; } List<MapEntryExpression> entries = new ArrayList<MapEntryExpression>(); for (PropertyNode pNode : props) { String name = pNode.getName(); entries.add(new MapEntryExpression(constX(name), propX(varX(mapParam), name))); AnnotationNode namedParam = new AnnotationNode(NAMED_PARAM_TYPE); namedParam.addMember("value", constX(name)); namedParam.addMember("type", classX(pNode.getType())); mapParam.addAnnotation(namedParam); } Expression delegateMap = new MapExpression(entries); args.addExpression(castX(fromParam.getType(), delegateMap)); return true; }
public void testIterateOverMap() throws Exception { MapExpression mapExpression = new MapExpression(); mapExpression.addMapEntryExpression(new ConstantExpression("a"), new ConstantExpression("x")); mapExpression.addMapEntryExpression(new ConstantExpression("b"), new ConstantExpression("y")); mapExpression.addMapEntryExpression(new ConstantExpression("c"), new ConstantExpression("z")); assertIterate("iterateOverMap", mapExpression); }
args.getExpressions().add(2, new MapExpression(savedMapEntries));
final MapExpression me = new MapExpression(); for (Expression expression : list.getExpressions()) { me.addMapEntryExpression((MapEntryExpression) transform(expression)); final MapExpression me = new MapExpression(); me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); me.setSourcePosition(be.getRightExpression());
public static MapExpression mapx(MapEntryExpression... entries) { MapExpression map = new MapExpression(); for (MapEntryExpression entry : entries) { map.addMapEntryExpression(entry); } return map; } }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer)); ret.setSourcePosition(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer)); ret.setSourcePosition(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer)); ret.setSourcePosition(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); return ret; }