本文整理汇总了Java中org.codehaus.groovy.ast.expr.ListExpression.getExpressions方法的典型用法代码示例。如果您正苦于以下问题:Java ListExpression.getExpressions方法的具体用法?Java ListExpression.getExpressions怎么用?Java ListExpression.getExpressions使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类org.codehaus.groovy.ast.expr.ListExpression
的用法示例。
在下文中一共展示了ListExpression.getExpressions方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: getConstantExpressions
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<ConstantExpression> getConstantExpressions(
ListExpression valueExpression) {
List<ConstantExpression> expressions = new ArrayList<ConstantExpression>();
for (Expression expression : valueExpression.getExpressions()) {
if (expression instanceof ConstantExpression
&& ((ConstantExpression) expression).getValue() instanceof String) {
expressions.add((ConstantExpression) expression);
}
else {
reportError(
"Each entry in the array must be an " + "inline string constant",
expression);
}
}
return expressions;
}
开发者ID:vikrammane23,项目名称:https-github.com-g0t4-jenkins2-course-spring-boot,代码行数:17,代码来源:DependencyManagementBomTransformation.java
示例2: transformInlineConstants
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private Expression transformInlineConstants(Expression exp) {
if (exp instanceof PropertyExpression) {
PropertyExpression pe = (PropertyExpression) exp;
if (pe.getObjectExpression() instanceof ClassExpression) {
ClassExpression ce = (ClassExpression) pe.getObjectExpression();
ClassNode type = ce.getType();
if (type.isEnum()) return exp;
Expression constant = findConstant(getField(type, pe.getPropertyAsString()));
if (constant != null) return constant;
}
} else if (exp instanceof ListExpression) {
ListExpression le = (ListExpression) exp;
ListExpression result = new ListExpression();
for (Expression e : le.getExpressions()) {
result.addExpression(transformInlineConstants(e));
}
return result;
}
return exp;
}
示例3: serialize
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private Expression serialize(Expression e) {
if (e instanceof AnnotationConstantExpression) {
AnnotationConstantExpression ace = (AnnotationConstantExpression) e;
return serialize((AnnotationNode) ace.getValue());
} else if (e instanceof ListExpression) {
boolean annotationConstant = false;
ListExpression le = (ListExpression) e;
List<Expression> list = le.getExpressions();
List<Expression> newList = new ArrayList<Expression>(list.size());
for (Expression exp: list) {
annotationConstant = annotationConstant || exp instanceof AnnotationConstantExpression;
newList.add(serialize(exp));
}
ClassNode type = ClassHelper.OBJECT_TYPE;
if (annotationConstant) type = type.makeArray();
return new ArrayExpression(type, newList);
}
return e;
}
示例4: getTargetListFromValue
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<AnnotationNode> getTargetListFromValue(AnnotationNode collector, AnnotationNode aliasAnnotationUsage, SourceUnit source) {
Expression memberValue = collector.getMember("value");
if (memberValue == null) {
return Collections.emptyList();
}
if (!(memberValue instanceof ListExpression)) {
addError("Annotation collector expected a list of classes, but got a "+memberValue.getClass(), collector, source);
return Collections.emptyList();
}
ListExpression memberListExp = (ListExpression) memberValue;
List<Expression> memberList = memberListExp.getExpressions();
if (memberList.isEmpty()) {
return Collections.emptyList();
}
List<AnnotationNode> ret = new ArrayList<AnnotationNode>();
for (Expression e : memberList) {
AnnotationNode toAdd = new AnnotationNode(e.getType());
toAdd.setSourcePosition(aliasAnnotationUsage);
ret.add(toAdd);
}
return ret;
}
示例5: getMemberList
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
@Deprecated
public List<String> getMemberList(AnnotationNode anno, String name) {
List<String> list;
Expression expr = anno.getMember(name);
if (expr != null && expr instanceof ListExpression) {
list = new ArrayList<String>();
final ListExpression listExpression = (ListExpression) expr;
for (Expression itemExpr : listExpression.getExpressions()) {
if (itemExpr != null && itemExpr instanceof ConstantExpression) {
Object value = ((ConstantExpression) itemExpr).getValue();
if (value != null) list.add(value.toString());
}
}
} else {
list = tokenize(getMemberStringValue(anno, name));
}
return list;
}
示例6: getKnownImmutableClasses
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<String> getKnownImmutableClasses(AnnotationNode node) {
final List<String> immutableClasses = new ArrayList<String>();
final Expression expression = node.getMember(MEMBER_KNOWN_IMMUTABLE_CLASSES);
if (expression == null) return immutableClasses;
if (!(expression instanceof ListExpression)) {
addError("Use the Groovy list notation [el1, el2] to specify known immutable classes via \"" + MEMBER_KNOWN_IMMUTABLE_CLASSES + "\"", node);
return immutableClasses;
}
final ListExpression listExpression = (ListExpression) expression;
for (Expression listItemExpression : listExpression.getExpressions()) {
if (listItemExpression instanceof ClassExpression) {
immutableClasses.add(listItemExpression.getType().getName());
}
}
return immutableClasses;
}
示例7: getKnownImmutables
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<String> getKnownImmutables(AnnotationNode node) {
final List<String> immutables = new ArrayList<String>();
final Expression expression = node.getMember(MEMBER_KNOWN_IMMUTABLES);
if (expression == null) return immutables;
if (!(expression instanceof ListExpression)) {
addError("Use the Groovy list notation [el1, el2] to specify known immutable property names via \"" + MEMBER_KNOWN_IMMUTABLES + "\"", node);
return immutables;
}
final ListExpression listExpression = (ListExpression) expression;
for (Expression listItemExpression : listExpression.getExpressions()) {
if (listItemExpression instanceof ConstantExpression) {
immutables.add((String) ((ConstantExpression) listItemExpression).getValue());
}
}
return immutables;
}
示例8: getConstantExpressions
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<ConstantExpression> getConstantExpressions(
ListExpression valueExpression) {
List<ConstantExpression> expressions = new ArrayList<ConstantExpression>();
for (Expression expression : valueExpression.getExpressions()) {
if (expression instanceof ConstantExpression
&& ((ConstantExpression) expression).getValue() instanceof String) {
expressions.add((ConstantExpression) expression);
}
}
return expressions;
}
开发者ID:vikrammane23,项目名称:https-github.com-g0t4-jenkins2-course-spring-boot,代码行数:12,代码来源:GenericBomAstTransformation.java
示例9: containsOnlyConstants
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private static boolean containsOnlyConstants(ListExpression list) {
for (Expression exp : list.getExpressions()) {
if (exp instanceof ConstantExpression) continue;
return false;
}
return true;
}
示例10: typeCheckMultipleAssignmentAndContinue
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private boolean typeCheckMultipleAssignmentAndContinue(Expression leftExpression, Expression rightExpression) {
// multiple assignment check
if (!(leftExpression instanceof TupleExpression)) return true;
if (!(rightExpression instanceof ListExpression)) {
addStaticTypeError("Multiple assignments without list expressions on the right hand side are unsupported in static type checking mode", rightExpression);
return false;
}
TupleExpression tuple = (TupleExpression) leftExpression;
ListExpression list = (ListExpression) rightExpression;
List<Expression> listExpressions = list.getExpressions();
List<Expression> tupleExpressions = tuple.getExpressions();
if (listExpressions.size() < tupleExpressions.size()) {
addStaticTypeError("Incorrect number of values. Expected:" + tupleExpressions.size() + " Was:" + listExpressions.size(), list);
return false;
}
for (int i = 0, tupleExpressionsSize = tupleExpressions.size(); i < tupleExpressionsSize; i++) {
Expression tupleExpression = tupleExpressions.get(i);
Expression listExpression = listExpressions.get(i);
ClassNode elemType = getType(listExpression);
ClassNode tupleType = getType(tupleExpression);
if (!isAssignableTo(elemType, tupleType)) {
addStaticTypeError("Cannot assign value of type " + elemType.toString(false) + " to variable of type " + tupleType.toString(false), rightExpression);
return false; // avoids too many errors
} else {
storeType(tupleExpression, elemType);
}
}
return true;
}
示例11: inferListExpressionType
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
protected ClassNode inferListExpressionType(final ListExpression list) {
List<Expression> expressions = list.getExpressions();
if (expressions.isEmpty()) {
// cannot infer, return list type
return list.getType();
}
ClassNode listType = list.getType();
GenericsType[] genericsTypes = listType.getGenericsTypes();
if ((genericsTypes == null
|| genericsTypes.length == 0
|| (genericsTypes.length == 1 && OBJECT_TYPE.equals(genericsTypes[0].getType())))
&& (!expressions.isEmpty())) {
// maybe we can infer the component type
List<ClassNode> nodes = new LinkedList<ClassNode>();
for (Expression expression : expressions) {
if (isNullConstant(expression)) {
// a null element is found in the list, skip it because we'll use the other elements from the list
} else {
nodes.add(getType(expression));
}
}
if (nodes.isEmpty()) {
// every element was the null constant
return listType;
}
ClassNode superType = getWrapper(lowestUpperBound(nodes)); // to be used in generics, type must be boxed
ClassNode inferred = listType.getPlainNodeReference();
inferred.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(superType))});
return inferred;
}
return listType;
}
示例12: transformArguments
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private List<Expression> transformArguments(final ListExpression expr) {
List<Expression> expressions = expr.getExpressions();
List<Expression> transformedArgs = new LinkedList<Expression>();
for (Expression expression : expressions) {
transformedArgs.add(transformer.transform(expression));
}
return transformedArgs;
}
示例13: determineTargets
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private static List<groovy.transform.PackageScopeTarget> determineTargets(Expression expr) {
List<groovy.transform.PackageScopeTarget> list = new ArrayList<groovy.transform.PackageScopeTarget>();
if (expr instanceof PropertyExpression) {
list.add(extractTarget((PropertyExpression) expr));
} else if (expr instanceof ListExpression) {
final ListExpression expressionList = (ListExpression) expr;
final List<Expression> expressions = expressionList.getExpressions();
for (Expression ex : expressions) {
if (ex instanceof PropertyExpression) {
list.add(extractTarget((PropertyExpression) ex));
}
}
}
return list;
}
示例14: checkDuplicateNameClashes
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private void checkDuplicateNameClashes(ListExpression list) {
final Set<String> seen = new HashSet<String>();
@SuppressWarnings("unchecked")
final List<ClassExpression> classes = (List)list.getExpressions();
for (ClassExpression ce : classes) {
final String name = ce.getType().getNameWithoutPackage();
if (seen.contains(name)) {
addError("Duplicate name '" + name + "' found during @" + MY_NAME + " processing.", ce);
}
seen.add(name);
}
}
示例15: checkClassLevelClashes
import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private void checkClassLevelClashes(ListExpression list) {
@SuppressWarnings("unchecked")
final List<ClassExpression> classes = (List)list.getExpressions();
for (ClassExpression ce : classes) {
final String name = ce.getType().getNameWithoutPackage();
if (findClassWithMatchingBasename(name)) {
addError("Error during @" + MY_NAME + " processing. Class '" + name + "' can't appear at " +
"method/constructor/field level if it already appears at the class level.", ce);
}
}
}