Examples with AnnotationRef io.sundr.model.AnnotationRef used on opensource projects

Example 11 with AnnotationRef

use of io.sundr.model.AnnotationRef in project sundrio by sundrio.

the class ClassTo method processAnnotatedElement.

private static void processAnnotatedElement(AnnotatedElement field, List<AnnotationRef> annotationRefs) {
    for (Annotation annotation : field.getDeclaredAnnotations()) {
        final Class<? extends Annotation> annotationType = annotation.annotationType();
        AnnotationRef annotationRef = ANNOTATIONTYPEREF.apply(annotationType);
        Map<String, Object> parameters = new HashMap<>();
        for (java.lang.reflect.Method method : annotationType.getDeclaredMethods()) {
            final String name = method.getName();
            try {
                final Object value = method.invoke(annotation, (Object[]) null);
                parameters.put(name, value);
            } catch (IllegalAccessException | InvocationTargetException e) {
                // Let's not pollute output with internal jdk stuff.
                if (!annotationType.getName().startsWith("jdk.")) {
                    System.out.printf("Couldn't retrieve '%s' parameter value for %s%n", name, annotationType.getName());
                }
            }
        }
        annotationRef = new AnnotationRefBuilder(annotationRef).withParameters(parameters).build();
        annotationRefs.add(annotationRef);
    }
}

Example 12 with AnnotationRef

use of io.sundr.model.AnnotationRef in project sundrio by sundrio.

the class ClassTo method getMethods.

private static Set<Method> getMethods(Class item, Set<Class> references) {
    Set<Method> methods = new HashSet<Method>();
    for (java.lang.reflect.Method method : item.getDeclaredMethods()) {
        List<AnnotationRef> annotationRefs = new ArrayList<>();
        List<ClassRef> exceptionRefs = new ArrayList<>();
        List<Property> arguments = new ArrayList<Property>();
        List<TypeParamDef> parameters = new ArrayList<TypeParamDef>();
        processMethod(references, method, annotationRefs, exceptionRefs, arguments, parameters);
        Map<AttributeKey, Object> attributes = new HashMap<>();
        if (method.getDefaultValue() != null) {
            attributes.put(Attributeable.DEFAULT_VALUE, String.valueOf(method.getDefaultValue()));
        }
        methods.add(new MethodBuilder().withName(method.getName()).withDefaultMethod(method.isDefault()).withModifiers(method.getModifiers()).withReturnType(TYPEREF.apply(method.getReturnType())).withArguments(arguments).withParameters(parameters).withExceptions(exceptionRefs).withAnnotations(annotationRefs).withAttributes(attributes).build());
    }
    return methods;
}

Example 13 with AnnotationRef

use of io.sundr.model.AnnotationRef in project sundrio by sundrio.

the class TypeDeclarationToTypeDef method apply.

@Override
public TypeDef apply(TypeDeclaration type) {
    if (type instanceof ClassOrInterfaceDeclaration) {
        ClassOrInterfaceDeclaration decl = (ClassOrInterfaceDeclaration) type;
        Kind kind = decl.isInterface() ? Kind.INTERFACE : Kind.CLASS;
        List<TypeParamDef> parameters = new ArrayList<TypeParamDef>();
        List<ClassRef> extendsList = new ArrayList<ClassRef>();
        List<ClassRef> implementsList = new ArrayList<ClassRef>();
        List<Property> properties = new ArrayList<Property>();
        List<Method> methods = new ArrayList<Method>();
        List<Method> constructors = new ArrayList<Method>();
        List<AnnotationRef> annotations = new ArrayList<AnnotationRef>();
        for (AnnotationExpr annotationExpr : decl.getAnnotations()) {
            annotations.add(ANNOTATIONREF.apply(annotationExpr));
        }
        for (TypeParameter typeParameter : decl.getTypeParameters()) {
            parameters.add(typeParameterToTypeParamDef.apply(typeParameter));
        }
        for (ClassOrInterfaceType classOrInterfaceType : decl.getExtends()) {
            extendsList.add((ClassRef) classOrInterfaceToTypeRef.apply(classOrInterfaceType));
        }
        for (ClassOrInterfaceType classOrInterfaceType : decl.getImplements()) {
            implementsList.add((ClassRef) classOrInterfaceToTypeRef.apply(classOrInterfaceType));
        }
        for (BodyDeclaration bodyDeclaration : decl.getMembers()) {
            if (bodyDeclaration instanceof FieldDeclaration) {
                FieldDeclaration fieldDeclaration = (FieldDeclaration) bodyDeclaration;
                for (VariableDeclarator var : fieldDeclaration.getVariables()) {
                    TypeRef fieldDeclRef = typeToTypeRef.apply(fieldDeclaration.getType());
                    TypeRef typeRef = checkAgainstTypeParamRef(fieldDeclRef, parameters);
                    properties.add(new PropertyBuilder().withName(var.getId().getName()).withTypeRef(typeRef).withModifiers(fieldDeclaration.getModifiers()).addToAttributes(Attributeable.INIT, var.getInit() != null ? var.getInit().toStringWithoutComments() : null).build());
                }
            } else if (bodyDeclaration instanceof MethodDeclaration) {
                MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
                List<Property> arguments = new ArrayList<Property>();
                List<ClassRef> exceptions = new ArrayList<ClassRef>();
                List<AnnotationRef> methodAnnotations = new ArrayList<AnnotationRef>();
                for (AnnotationExpr annotationExpr : methodDeclaration.getAnnotations()) {
                    methodAnnotations.add(ANNOTATIONREF.apply(annotationExpr));
                }
                for (ReferenceType referenceType : methodDeclaration.getThrows()) {
                    TypeRef exceptionRef = typeToTypeRef.apply(referenceType.getType());
                    if (exceptionRef instanceof ClassRef) {
                        exceptions.add((ClassRef) exceptionRef);
                    }
                }
                Boolean preferVarArg = false;
                for (Parameter parameter : methodDeclaration.getParameters()) {
                    List<AnnotationRef> paramAnnotations = new ArrayList<AnnotationRef>();
                    for (AnnotationExpr annotationExpr : parameter.getAnnotations()) {
                        paramAnnotations.add(ANNOTATIONREF.apply(annotationExpr));
                    }
                    TypeRef typeRef = typeToTypeRef.apply(parameter.getType());
                    if (parameter.isVarArgs()) {
                        preferVarArg = true;
                        typeRef = typeRef.withDimensions(typeRef.getDimensions() + 1);
                    }
                    arguments.add(new PropertyBuilder().withName(parameter.getId().getName()).withTypeRef(typeRef).withModifiers(parameter.getModifiers()).withAnnotations(paramAnnotations).build());
                }
                List<TypeParamDef> typeParamDefs = new ArrayList<TypeParamDef>();
                for (TypeParameter typeParameter : methodDeclaration.getTypeParameters()) {
                    typeParamDefs.add(typeParameterToTypeParamDef.apply(typeParameter));
                }
                TypeRef returnType = checkAgainstTypeParamRef(typeToTypeRef.apply(methodDeclaration.getType()), parameters);
                methods.add(new MethodBuilder().withName(methodDeclaration.getName()).withDefaultMethod(methodDeclaration.isDefault()).withModifiers(methodDeclaration.getModifiers()).withParameters(typeParamDefs).withVarArgPreferred(preferVarArg).withReturnType(returnType).withExceptions(exceptions).withArguments(arguments).withAnnotations(methodAnnotations).withBlock(BLOCK.apply(methodDeclaration.getBody())).build());
            } else if (bodyDeclaration instanceof ConstructorDeclaration) {
                ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) bodyDeclaration;
                List<Property> arguments = new ArrayList<Property>();
                List<ClassRef> exceptions = new ArrayList<ClassRef>();
                List<AnnotationRef> ctorAnnotations = new ArrayList<AnnotationRef>();
                for (AnnotationExpr annotationExpr : constructorDeclaration.getAnnotations()) {
                    ctorAnnotations.add(ANNOTATIONREF.apply(annotationExpr));
                }
                for (ReferenceType referenceType : constructorDeclaration.getThrows()) {
                    TypeRef exceptionRef = typeToTypeRef.apply(referenceType.getType());
                    exceptions.add((ClassRef) exceptionRef);
                }
                for (Parameter parameter : constructorDeclaration.getParameters()) {
                    List<AnnotationRef> ctorParamAnnotations = new ArrayList<AnnotationRef>();
                    for (AnnotationExpr annotationExpr : parameter.getAnnotations()) {
                        ctorParamAnnotations.add(ANNOTATIONREF.apply(annotationExpr));
                    }
                    TypeRef typeRef = checkAgainstTypeParamRef(typeToTypeRef.apply(parameter.getType()), parameters);
                    arguments.add(new PropertyBuilder().withName(parameter.getId().getName()).withTypeRef(typeRef).withModifiers(parameter.getModifiers()).withAnnotations(ctorParamAnnotations).build());
                }
                constructors.add(new MethodBuilder().withModifiers(constructorDeclaration.getModifiers()).withExceptions(exceptions).withArguments(arguments).withAnnotations(ctorAnnotations).withBlock(BLOCK.apply(constructorDeclaration.getBlock())).build());
            }
        }
        return context.getDefinitionRepository().register(new TypeDefBuilder().withKind(kind).withPackageName(PACKAGENAME.apply(type)).withName(decl.getName()).withModifiers(type.getModifiers()).withParameters(parameters).withExtendsList(extendsList).withImplementsList(implementsList).withProperties(properties).withMethods(methods).withConstructors(constructors).withAnnotations(annotations).addToAttributes(TypeDef.ALSO_IMPORT, IMPORTS.apply(type)).build());
    }
    if (type instanceof AnnotationDeclaration) {
        AnnotationDeclaration decl = (AnnotationDeclaration) type;
        Kind kind = Kind.ANNOTATION;
        List<Method> methods = new ArrayList<Method>();
        for (BodyDeclaration bodyDeclaration : decl.getMembers()) {
            if (bodyDeclaration instanceof AnnotationMemberDeclaration) {
                Map<AttributeKey, Object> attributes = new HashMap<>();
                AnnotationMemberDeclaration annotationMemberDeclaration = (AnnotationMemberDeclaration) bodyDeclaration;
                if (annotationMemberDeclaration.getDefaultValue() != null) {
                    attributes.put(Attributeable.DEFAULT_VALUE, annotationMemberDeclaration.getDefaultValue().toString());
                }
                TypeRef returnType = typeToTypeRef.apply(annotationMemberDeclaration.getType());
                methods.add(new MethodBuilder().withName(annotationMemberDeclaration.getName()).withModifiers(annotationMemberDeclaration.getModifiers()).withReturnType(returnType).withAttributes(attributes).build());
            }
        }
        List<AnnotationRef> annotations = new ArrayList<AnnotationRef>();
        for (AnnotationExpr annotationExpr : decl.getAnnotations()) {
            annotations.add(ANNOTATIONREF.apply(annotationExpr));
        }
        return context.getDefinitionRepository().register(new TypeDefBuilder().withKind(kind).withPackageName(PACKAGENAME.apply(type)).withName(decl.getName()).withModifiers(type.getModifiers()).withMethods(methods).withAnnotations(annotations).addToAttributes(TypeDef.ALSO_IMPORT, IMPORTS.apply(type)).build());
    }
    throw new IllegalArgumentException("Unsupported TypeDeclaration:[" + type + "].");
}

Example 14 with AnnotationRef

use of io.sundr.model.AnnotationRef in project sundrio by sundrio.

the class AbstractAdapterTest method testClassWithAnnotationParams.

@Test
public void testClassWithAnnotationParams() {
    T input = getInput(ClassWithAnnotation.class);
    TypeDef typeDef = Adapters.adaptType(input, getContext());
    final List<Property> properties = typeDef.getProperties();
    final Property foo = properties.stream().filter(p -> p.getName().equals("foo")).findFirst().orElseThrow(RuntimeException::new);
    List<AnnotationRef> annotations = foo.getAnnotations();
    assertEquals(1, annotations.size());
    AnnotationRef annotationRef = annotations.get(0);
    assertTrue(annotationRef.toString().contains("SimpleAnnotation"));
    assertEquals("foo", annotationRef.getParameters().get("name"));
    final Method bar = typeDef.getMethods().stream().filter(p -> p.getName().equals("bar")).findFirst().orElseThrow(RuntimeException::new);
    annotations = bar.getAnnotations();
    assertEquals(1, annotations.size());
    annotationRef = annotations.get(0);
    assertEquals("bar", annotationRef.getParameters().get("name"));
    Object params = annotationRef.getParameters().get("values");
    assertArrayEquals(new int[] { 1, 2, 3, 5, 7 }, (int[]) annotationRef.getParameters().get("values"));
}