private boolean resolveGenericsTypes(GenericsType[] types) { if (types == null) return true; currentClass.setUsingGenerics(true); boolean resolved = true; for (GenericsType type : types) { // attempt resolution on all types, so don't short-circuit and stop if we've previously failed resolved = resolveGenericsType(type) && resolved; } return resolved; }
result = ClassHelper.make(className); result.setUsingGenerics(dis.readBoolean()); int len = dis.readInt(); if (len >= 0) {
private static ClassNode makeRawType(final ClassNode receiver) { if (receiver.isArray()) { return makeRawType(receiver.getComponentType()).makeArray(); } ClassNode raw = receiver.getPlainNodeReference(); raw.setUsingGenerics(false); raw.setGenericsTypes(null); return raw; }
private void resolveGenericsHeader(GenericsType[] types, GenericsType rootType, int level) { if (types == null) return; currentClass.setUsingGenerics(true); List<Tuple2<ClassNode, GenericsType>> upperBoundsWithGenerics = new LinkedList<>(); List<Tuple2<ClassNode, ClassNode>> upperBoundsToResolve = new LinkedList<>();
public static ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } if (type.isArray() && type.getComponentType().isUsingGenerics()) { return type.getComponentType().getPlainNodeReference().makeArray(); } return type; }
private boolean resolveGenericsType(GenericsType genericsType) { if (genericsType.isResolved()) return true; currentClass.setUsingGenerics(true); ClassNode type = genericsType.getType();
/** * Informs the builder whether to use generics in the resulting {@link ClassNode} * or not. * * @param useGenerics true if it should use generics * @return current instance of {@link ClassNodeBuilder} * @since 0.1.0 */ public ClassNodeBuilder usingGenerics(final Boolean useGenerics) { this.classNode.setUsingGenerics(useGenerics); return this; }
private void resolveGenericsTypes(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (int i = 0; i < types.length; i++) { resolveGenericsType(types[i]); } }
private void resolveGenericsTypes(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (int i = 0; i < types.length; i++) { resolveGenericsType(types[i]); } }
private void resolveGenericsTypes(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (GenericsType type : types) { resolveGenericsType(type); } }
private boolean resolveGenericsTypes(GenericsType[] types) { if (types == null) { return true; } currentClass.setUsingGenerics(true); boolean resolved = true; for (GenericsType type : types) { // attempt resolution on all types, so don't short-circuit and stop if we've previously failed resolved = resolveGenericsType(type) && resolved; } return resolved; }
private void resolveGenericsTypes(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (int i = 0; i < types.length; i++) { resolveGenericsType(types[i]); } }
public static ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } if (type.isArray()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(Object.class); nonGen.setUsingGenerics(false); return nonGen.makeArray(); } return type.getPlainNodeReference(); }
private static ClassNode nonGeneric(final ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } else { return type; } }
private ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } else { return type; } } }
private ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.make(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } else { return type; } } }
private void resolveGenericsHeader(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (int i = 0; i < types.length; i++) { ClassNode type = types[i].getType(); String name = type.getName(); ClassNode[] bounds = types[i].getUpperBounds(); if (bounds != null) { boolean nameAdded = false; for (int j = 0; j < bounds.length; j++) { ClassNode upperBound = bounds[j]; if (!nameAdded && upperBound != null || !resolve(type)) { genericParameterNames.put(name, types[i]); types[i].setPlaceholder(true); type.setRedirect(upperBound); nameAdded = true; } resolveOrFail(upperBound, type); } } else { genericParameterNames.put(name, types[i]); type.setRedirect(ClassHelper.OBJECT_TYPE); types[i].setPlaceholder(true); } } }
private void resolveGenericsHeader(GenericsType[] types) { if (types == null) { return; } currentClass.setUsingGenerics(true); for (GenericsType type : types) { ClassNode classNode = type.getType(); String name = type.getName(); ClassNode[] bounds = type.getUpperBounds(); if (bounds != null) { boolean nameAdded = false; for (ClassNode upperBound : bounds) { if (!nameAdded && upperBound != null || !resolve(classNode)) { genericParameterNames.put(name, type); type.setPlaceholder(true); classNode.setRedirect(upperBound); nameAdded = true; } resolveOrFail(upperBound, classNode); } } else { genericParameterNames.put(name, type); classNode.setRedirect(ClassHelper.OBJECT_TYPE); type.setPlaceholder(true); } } }
private ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } else if (type.isArray() && type.getComponentType().isUsingGenerics()) { return type.getComponentType().getPlainNodeReference().makeArray(); } else { return type; } }
@Override protected void performInjectionInternal(String apiInstanceProperty, SourceUnit source, ClassNode classNode) { classNode.setUsingGenerics(true); GrailsASTUtils.addAnnotationIfNecessary(classNode, Entity.class); final BlockStatement methodBody = new BlockStatement(); methodBody.addStatement(new ExpressionStatement(new MethodCallExpression(new ClassExpression(classNode), NEW_INSTANCE_METHOD,ZERO_ARGS))); MethodNode methodNode = classNode.getDeclaredMethod(CreateDynamicMethod.METHOD_NAME, ZERO_PARAMETERS); classNode = GrailsASTUtils.nonGeneric(classNode); if (methodNode == null) { classNode.addMethod(new MethodNode(CreateDynamicMethod.METHOD_NAME, PUBLIC_STATIC_MODIFIER, classNode, ZERO_PARAMETERS,null, methodBody)); } }