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

Example 1 with WildcardRefBuilder

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

the class TypeToTypeRef method apply.

@Override
public TypeRef apply(Type item) {
    if (item == null) {
        return new VoidRefBuilder().build();
    } else if (item instanceof WildcardType) {
        return new WildcardRefBuilder().withBounds(Arrays.asList(((WildcardType) item).getLowerBounds()).stream().map(t -> apply(t)).collect(Collectors.toList())).build();
    } else if (item instanceof TypeVariable) {
        return new TypeParamRefBuilder().withName(((TypeVariable) item).getName()).build();
    } else if (item instanceof GenericArrayType) {
        Type target = item;
        int dimensions = 0;
        while (target instanceof GenericArrayType) {
            target = ((GenericArrayType) target).getGenericComponentType();
            dimensions++;
        }
        if (target instanceof Class) {
            references.add((Class) target);
        }
        TypeRef targetRef = apply(target);
        return targetRef.withDimensions(dimensions + targetRef.getDimensions());
    } else if (item instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) item;
        Type rawType = parameterizedType.getRawType();
        List<TypeRef> arguments = new ArrayList<TypeRef>();
        for (Type arg : parameterizedType.getActualTypeArguments()) {
            arguments.add(apply(arg));
            if (arg instanceof Class) {
                references.add((Class) arg);
            }
        }
        if (rawType instanceof Class) {
            references.add((Class) rawType);
        }
        return new ClassRefBuilder((ClassRef) apply(rawType)).withArguments(arguments).build();
    } else if (Object.class.equals(item)) {
        return ClassRef.OBJECT;
    } else if (item instanceof Class) {
        Class c = (Class) item;
        if (c.isArray()) {
            Class target = c;
            int dimensions = 0;
            while (target.isArray()) {
                target = ((Class) target).getComponentType();
                dimensions++;
            }
            TypeRef targetRef = apply(target);
            references.add(target);
            return targetRef.withDimensions(dimensions + targetRef.getDimensions());
        }
        if (c.isPrimitive()) {
            return new PrimitiveRefBuilder().withName(c.getName()).withDimensions(0).build();
        } else {
            List<TypeRef> arguments = new ArrayList<TypeRef>();
            for (TypeVariable v : c.getTypeParameters()) {
                arguments.add(apply(v));
            }
            references.add((Class) item);
            String fqcn = c.getName().replaceAll(Pattern.quote("$"), ".");
            return new ClassRefBuilder().withFullyQualifiedName(fqcn).withArguments(arguments).build();
        }
    }
    throw new IllegalArgumentException("Can't convert type:" + item + " to a TypeRef");
}

Example 2 with WildcardRefBuilder

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

the class ClassOrInterfaceToTypeRef method apply.

@Override
public TypeRef apply(ClassOrInterfaceType classOrInterfaceType) {
    String boundPackage = PACKAGENAME.apply(classOrInterfaceType);
    String boundName = classOrInterfaceType.getName();
    List<TypeRef> arguments = new ArrayList<TypeRef>();
    for (Type arg : classOrInterfaceType.getTypeArgs()) {
        if (arg instanceof ReferenceType) {
            // TODO: Need to check if this is valid for all cases...
            ReferenceType referenceType = (ReferenceType) arg;
            Type type = referenceType.getType();
            int dimensions = referenceType.getArrayCount();
            if (type instanceof ClassOrInterfaceType) {
                TypeRef intermediateRef = apply((ClassOrInterfaceType) type);
                if (intermediateRef instanceof ClassRef) {
                    arguments.add(new ClassRefBuilder((ClassRef) intermediateRef).withDimensions(dimensions).build());
                } else if (intermediateRef instanceof TypeParamRef) {
                    arguments.add(new TypeParamRefBuilder((TypeParamRef) intermediateRef).withDimensions(dimensions).build());
                } else {
                    throw new IllegalStateException("Expected class or type param reference");
                }
            } else {
                String name = referenceType.toString();
                arguments.add(new TypeParamRefBuilder().withName(name).withDimensions(dimensions).build());
            }
        } else if (arg instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) arg;
            if (wildcardType.getExtends() != null) {
                TypeRef bound = typeToTypeRef.apply(wildcardType.getExtends());
                arguments.add(new WildcardRefBuilder().addToBounds(bound).build());
            } else if (wildcardType.getSuper() != null) {
                TypeRef bound = typeToTypeRef.apply(wildcardType.getSuper());
                arguments.add(new WildcardRefBuilder().addToBounds(bound).withBoundKind(WildcardRef.BoundKind.SUPER).build());
            } else {
                arguments.add(new WildcardRef());
            }
        }
    }
    if (classOrInterfaceType.getParentNode() == classOrInterfaceType) {
        return new TypeParamRefBuilder().withName(boundName).build();
    }
    String fqcn = boundPackage + "." + boundName;
    // : knownDefinition.toReference(arguments);
    if (classOrInterfaceType.getTypeArgs().isEmpty() && boundName.length() == 1) {
        // parameter refs.
        return new TypeParamRefBuilder().withName(boundName).build();
    } else {
        return new ClassRefBuilder().withFullyQualifiedName(fqcn).withArguments(arguments).build();
    }
}