private static boolean isRefType(Type in, String className) { // Does not check type parameters if (in instanceof ClassOrInterfaceType) { return (className.equals(((ClassOrInterfaceType) in).getNameAsString())); } return false; }
private static boolean isRefType(Type in, String className) { // Does not check type parameters if (in instanceof ClassOrInterfaceType) { return (className.equals(((ClassOrInterfaceType) in).getNameAsString())); } return false; }
@Override public void visit(ClassOrInterfaceType n, Void arg) { out.println("ClassOrInterfaceType: " + (extended ? n : n.getNameAsString())); super.visit(n, arg); }
private static void replaceParentClassesForAtomics(NodeList<ClassOrInterfaceType> types) { for (ClassOrInterfaceType parent : types) { if ("BaseLinkedQueue".equals(parent.getNameAsString())) { parent.setName("BaseLinkedAtomicQueue"); } else { // Padded super classes are to be renamed and thus so does the // class we must extend. parent.setName(translateQueueName(parent.getNameAsString())); } } }
/** * Searches all extended or implemented super classes or interfaces for * special classes that differ with the atomics version and replaces them * with the appropriate class. * * @param n */ private static void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) { for (ClassOrInterfaceType parent : n.getExtendedTypes()) { if ("ConcurrentCircularArrayQueue".equals(parent.getNameAsString())) { parent.setName("AtomicReferenceArrayQueue"); } else if ("ConcurrentSequencedCircularArrayQueue".equals(parent.getNameAsString())) { parent.setName("SequencedAtomicReferenceArrayQueue"); } else { // Padded super classes are to be renamed and thus so does the // class we must extend. parent.setName(translateQueueName(parent.getNameAsString())); } } }
private static boolean shouldTypeBeExcluded(final ClassOrInterfaceType type) { return type.getNameAsString().matches( String.class.getSimpleName() + '|' + Integer.class.getSimpleName() + '|' + Double.class.getSimpleName() + '|' + Long.class.getSimpleName() + '|' + Float.class.getSimpleName() + '|' + Boolean.class.getSimpleName() + '|' + PrincipalTransformationProperties.CaseConversion.class.getSimpleName() + '|' + QueryType.class.getSimpleName() + '|' + AbstractLdapProperties.LdapType.class.getSimpleName() + '|' + CaseCanonicalizationMode.class.getSimpleName() + '|' + PasswordPolicyProperties.PasswordPolicyHandlingOptions.class.getSimpleName() + '|' + LdapSearchEntryHandlersProperties.SearchEntryHandlerTypes.class.getSimpleName() + '|' + Map.class.getSimpleName() + '|' + Resource.class.getSimpleName() + '|' + List.class.getSimpleName() + '|' + Set.class.getSimpleName()); }
private String getTypeName(Type t) { // if (t instanceof ReferenceType) { // t = ((ReferenceType<?>)t).getType(); // } if (t instanceof PrimitiveType) { return ((PrimitiveType)t).toString(); } if (t instanceof ClassOrInterfaceType) { return ((ClassOrInterfaceType)t).getNameAsString(); } Misc.internalError(); return null; }
/** * Locate properties class for type class. * * @param type the type * @return the class */ public Class locatePropertiesClassForType(final ClassOrInterfaceType type) { if (cachedPropertiesClasses.containsKey(type.getNameAsString())) { return cachedPropertiesClasses.get(type.getNameAsString()); } val packageName = ConfigurationMetadataGenerator.class.getPackage().getName(); val reflections = new Reflections(new ConfigurationBuilder() .filterInputsBy(s -> s.contains(type.getNameAsString())) .setUrls(ClasspathHelper.forPackage(packageName)) .setScanners(new TypeElementsScanner() .includeFields(false) .includeMethods(false) .includeAnnotations(false) .filterResultsBy(s -> s.endsWith(type.getNameAsString())), new SubTypesScanner(false))); val clz = reflections.getSubTypesOf(Serializable.class).stream() .filter(c -> c.getSimpleName().equalsIgnoreCase(type.getNameAsString())) .findFirst() .orElseThrow(() -> new IllegalArgumentException("Cant locate class for " + type.getNameAsString())); cachedPropertiesClasses.put(type.getNameAsString(), clz); return clz; } }
public void calculate(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, CompilationUnit compilationUnit) { List<ClassOrInterfaceType> extendedTypes = classOrInterfaceDeclaration.getExtendedTypes(); for (ClassOrInterfaceType extendedType : extendedTypes) { String extendedTypeName = extendedType.getNameAsString(); String extendedTypePackageName = extendedType .findCompilationUnit() .flatMap(CompilationUnit::getPackageDeclaration) .flatMap(pkg -> Optional.of(pkg.getNameAsString())).orElse("???"); if (typeDao.exist(extendedTypeName, extendedTypePackageName)) { // JDK interfaces are not indexed int extendedInterfaceId = typeDao.getId(extendedTypeName, extendedTypePackageName); int interfaceId = typeDao.getId(classOrInterfaceDeclaration.getNameAsString(), compilationUnit.getPackageDeclaration().get().getNameAsString()); extendsDao.save(new Extends(interfaceId, extendedInterfaceId)); } } } }
private void setAttributes(ClassBuilder builder, ClassOrInterfaceDeclaration n) { builder.withName(n.getNameAsString()); if (isClass(n)) { CanonicalNameFactory factory = new CanonicalNameFactory(packageName, imports); n.getExtendedTypes().stream().findFirst() .ifPresent(parent -> builder.withParent(new Parent(factory.build(parent.getNameAsString())))); } }
public void calculate(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, CompilationUnit compilationUnit) { List<ClassOrInterfaceType> implementedInterfaces = classOrInterfaceDeclaration.getImplementedTypes(); for (ClassOrInterfaceType implementedInterface : implementedInterfaces) { String implementedInterfaceName = implementedInterface.getNameAsString(); String implementedInterfacePackageName = implementedInterface .findCompilationUnit() .flatMap(CompilationUnit::getPackageDeclaration) .flatMap(pkg -> Optional.of(pkg.getNameAsString())).orElse("???"); if (typeDao.exist(implementedInterfaceName, implementedInterfacePackageName)) { // JDK interfaces are not indexed int interfaceId = typeDao.getId(implementedInterfaceName, implementedInterfacePackageName); String cuPackageName = compilationUnit.getPackageDeclaration().get().getNameAsString(); int nbClasses = typeDao.count(classOrInterfaceDeclaration.getNameAsString(), cuPackageName); if (nbClasses > 1) { System.err.println("More than one class having the same name '" + classOrInterfaceDeclaration.getName() + "' and package '" + cuPackageName + "'"); } else { int classId = typeDao.getId(classOrInterfaceDeclaration.getNameAsString(), cuPackageName); implementsDao.save(new Implements(classId, interfaceId)); } } } } }