private static void populateClasses( final Shell shell, final IParent parent, final List<IType> types, final Filter filter) { try { for (final IJavaElement element : parent.getChildren()) { if (element instanceof IType) { final IType type = (IType) element; if (type.isClass() && type.isStructureKnown() && !type.isAnonymous() && !type.isLocal() && !Flags.isAbstract(type.getFlags()) && Flags.isPublic(type.getFlags()) && (filter == null || filter.accept(type))) { types.add(type); } } else if (element instanceof IParent && !element.getPath().toString().contains("/test/") && (!(element instanceof IPackageFragmentRoot) || !((IPackageFragmentRoot) element).isExternal())) { populateClasses(shell, (IParent) element, types, filter); } } } catch (final JavaModelException e) { Activator.error(e); } }
public void testFlagsOfRoFi2() throws JavaModelException { assertNotNull(getTestSetting().getTeamJavaElement()); assertTrue(getTestSetting().getTeamJavaElement().exists()); IType r2 = getTestSetting().getTeamJavaElement().getType(R2); int flags = r2.getFlags(); assertEquals("Unexpected flags", Flags.AccPublic | Flags.AccTeam | Flags.AccRole, flags); }
/** * Method to post process returned flags from the {@link * org.eclipse.pde.api.tools.internal.JavadocTagManager} * * @param tag the tag to process * @param element the {@link IJavaElement} the tag will appear on * @return true if the tag should be included in completion proposals, false otherwise */ private boolean acceptTag(IApiJavadocTag tag, IJavaElement element) throws JavaModelException { if (fExistingTags != null) { Boolean fragments = fExistingTags.get(tag.getTagName()); // if the tag has a fragment don't overwrite / propose again if (fragments != null && Boolean.FALSE.equals(fragments)) { return false; } } switch (element.getElementType()) { case IJavaElement.TYPE: { IType type = (IType) element; int flags = type.getFlags(); String tagname = tag.getTagName(); if (Flags.isAbstract(flags)) { return !tagname.equals(JavadocTagManager.TAG_NOINSTANTIATE); } if (Flags.isFinal(flags)) { return !tagname.equals(JavadocTagManager.TAG_NOEXTEND); } break; } case IJavaElement.METHOD: { IMethod method = (IMethod) element; if (Flags.isFinal(method.getFlags()) || Flags.isStatic(method.getFlags())) { return !tag.getTagName().equals(JavadocTagManager.TAG_NOOVERRIDE); } IType type = method.getDeclaringType(); if (type != null && Flags.isFinal(type.getFlags())) { return !tag.getTagName().equals(JavadocTagManager.TAG_NOOVERRIDE); } break; } default: break; } return true; }
/** * This method asks the specified <code>IType</code> if it has a main method, if not it recurses * through all of its children When recursing we only care about child <code>IType</code>s that * are static. * * @param type the <code>IType</code> to inspect for a main method * @return true if a main method was found in specified <code>IType</code>, false otherwise * @throws CoreException * @since 3.3 */ private boolean hasMainInChildren(IType type) throws CoreException { if (type.isClass() & Flags.isStatic(type.getFlags())) { if (hasMainMethod(type)) { return true; } else { IJavaElement[] children = type.getChildren(); for (int i = 0; i < children.length; i++) { if (children[i].getElementType() == IJavaElement.TYPE) { return hasMainInChildren((IType) children[i]); } } } } return false; }
/** * @since 2.3 * @deprecated This method is not used anymore. */ @Deprecated protected IType getPrimaryTypeFrom(ICompilationUnit cu) { try { if (cu.exists()) { IType primaryType = cu.findPrimaryType(); if (primaryType != null) return primaryType; // if no exact match is found, return the first public type in CU (if any) for (IType type : cu.getTypes()) { if (Flags.isPublic(type.getFlags())) return type; } } } catch (JavaModelException e) { if (LOGGER.isDebugEnabled()) LOGGER.debug(e, e); } return null; }
/** * Returns if the given {@link IJavaElement} is externally visible <br> * <br> * Changes to the logic here must also be made in the {@link TagValidator} to ensure the * visibility is computed equally. * * @see TagValidator * @param element * @return <code>true</code> if the given element is visible <code>false</code> otherwise * @throws JavaModelException if a model lookup fails */ boolean isVisible(IJavaElement element) throws JavaModelException { if (element != null) { switch (element.getElementType()) { case IJavaElement.FIELD: case IJavaElement.METHOD: { IMember member = (IMember) element; int flags = member.getFlags(); IType type = member.getDeclaringType(); if (Flags.isPublic(flags) || Flags.isProtected(flags) || (type != null && type.isInterface())) { return isVisible(type); } break; } case IJavaElement.TYPE: { IType type = (IType) element; int flags = type.getFlags(); if (type.isLocal() && !type.isAnonymous() || Flags.isPrivate(flags)) { return false; } if (type.isMember()) { if ((Flags.isPublic(flags) && Flags.isStatic(flags)) || Flags.isPublic(flags) || Flags.isProtected(flags) || type.isInterface()) { return isVisible(type.getDeclaringType()); } } else { return Flags.isPublic(flags) || type.isInterface(); } break; } default: { break; } } } return false; }
/** @see IJavaElementRequestor */ public void acceptType(IType type) { try { if (this.unitToSkip != null && this.unitToSkip.equals(type.getCompilationUnit())) { return; } char[] packageName = type.getPackageFragment().getElementName().toCharArray(); boolean isBinary = type instanceof BinaryType; // determine associated access restriction AccessRestriction accessRestriction = null; if (this.checkAccessRestrictions && (isBinary || !type.getJavaProject().equals(this.project))) { PackageFragmentRoot root = (PackageFragmentRoot) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); ClasspathEntry entry = (ClasspathEntry) this.nameLookup.rootToResolvedEntries.get(root); if (entry != null) { // reverse map always contains resolved CP entry AccessRuleSet accessRuleSet = entry.getAccessRuleSet(); if (accessRuleSet != null) { // TODO (philippe) improve char[] <-> String conversions to avoid performing them on the // fly char[][] packageChars = CharOperation.splitOn('.', packageName); char[] fileWithoutExtension = type.getElementName().toCharArray(); accessRestriction = accessRuleSet.getViolatedRestriction( CharOperation.concatWith(packageChars, fileWithoutExtension, '/')); } } } this.requestor.acceptType( packageName, type.getElementName().toCharArray(), null, type.getFlags(), accessRestriction); } catch (JavaModelException jme) { // ignore } }
private synchronized void internalCheckConsistency(IProgressMonitor monitor) throws OperationCanceledException { // Setting fNeedsConsistencyCheck is necessary here since // markAsInconsistent isn't synchronized. fNeedsConsistencyCheck = true; List typesToCheck = new ArrayList(getKeys()); monitor.beginTask(CorextMessages.TypeInfoHistory_consistency_check, typesToCheck.size()); monitor.setTaskName(CorextMessages.TypeInfoHistory_consistency_check); for (Iterator iter = typesToCheck.iterator(); iter.hasNext(); ) { TypeNameMatch type = (TypeNameMatch) iter.next(); long currentTimestamp = getContainerTimestamp(type); Long lastTested = (Long) fTimestampMapping.get(type); if (lastTested != null && currentTimestamp != IResource.NULL_STAMP && currentTimestamp == lastTested.longValue() && !isContainerDirty(type)) continue; try { IType jType = type.getType(); if (jType == null || !jType.exists()) { remove(type); } else { // copy over the modifiers since they may have changed int modifiers = jType.getFlags(); if (modifiers != type.getModifiers()) { replace(type, SearchEngine.createTypeNameMatch(jType, modifiers)); } else { fTimestampMapping.put(type, new Long(currentTimestamp)); } } } catch (JavaModelException e) { remove(type); } if (monitor.isCanceled()) throw new OperationCanceledException(); monitor.worked(1); } monitor.done(); fNeedsConsistencyCheck = false; }
public void testNewBeanWizard() throws Exception { WizardContext context = new WizardContext(); context.init("org.jboss.tools.cdi.ui.wizard.NewBeanCreationWizard", PACK_NAME, BEAN_NAME); ICDIProject cdi = CDICorePlugin.getCDIProject(context.tck, true); try { NewBeanWizardPage page = (NewBeanWizardPage) context.page; page.setBeanName("myNewBean"); page.setScope(CDIConstants.SESSION_SCOPED_ANNOTATION_TYPE_NAME); String message = page.getMessage(); assertEquals(CDIUIMessages.MESSAGE_BEAN_SHOULD_BE_SERIALIZABLE, message); assertEquals(IMessageProvider.WARNING, page.getMessageType()); page.setScope(CDIConstants.APPLICATION_SCOPED_ANNOTATION_TYPE_NAME); assertEquals(IMessageProvider.NONE, page.getMessageType()); context.wizard.performFinish(); String text = context.getNewTypeContent(); // System.out.println(text); assertTrue(text.contains("@Named")); assertTrue(text.contains("\"myNewBean\"")); IType type = (IType) context.wizard.getCreatedElement(); int f = type.getFlags(); assertTrue(Modifier.isPublic(f)); assertFalse(Modifier.isAbstract(f)); // String[] is = type.getSuperInterfaceNames(); // assertEquals(1, is.length); // assertEquals("Serializable", is[0]); } finally { context.close(); } }
private void extractIType(IType type) { try { String fqn = type.getFullyQualifiedName(); // Write the entity if (type.isClass()) { entityWriter.writeClass(fqn, type.getFlags(), path); // Write the superclass String superSig = type.getSuperclassTypeSignature(); if (superSig != null) { relationWriter.writeExtends(fqn, typeSignatureToFqn(superSig), path); } } else if (type.isAnnotation()) { entityWriter.writeAnnotation(fqn, type.getFlags(), path); } else if (type.isInterface()) { entityWriter.writeInterface(fqn, type.getFlags(), path); } else if (type.isEnum()) { entityWriter.writeEnum(fqn, type.getFlags(), path); } // Write the superinterfaces for (String superIntSig : type.getSuperInterfaceTypeSignatures()) { relationWriter.writeImplements(fqn, typeSignatureToFqn(superIntSig), path); } if (!fqnStack.isEmpty()) { relationWriter.writeInside(type.getFullyQualifiedName(), fqnStack.peek(), path); } fqnStack.push(type.getFullyQualifiedName()); for (IType child : type.getTypes()) { extractIType(child); } for (IField field : type.getFields()) { if (!Flags.isSynthetic(field.getFlags())) { extractIField(field); } } for (IMethod method : type.getMethods()) { if (!Flags.isSynthetic(method.getFlags()) || (Flags.isSynthetic(method.getFlags()) && method.isConstructor() && method.getParameterTypes().length == 0)) { extractIMethod(method, type.isAnnotation()); } } int pos = 0; for (ITypeParameter param : type.getTypeParameters()) { relationWriter.writeParametrizedBy(fqn, getTypeParam(param), pos++, path); } fqnStack.pop(); } catch (Exception e) { logger.log(Level.SEVERE, "Error in extracting class file", e); } }
/** * @param insideTagBody * @param tagBody * @param templateTag * @param contextMap * @param placeHolders * @param spacesBeforeCursor * @param overrideMethods * @param exist * @param overWrite * @param type * @throws JavaModelException * @throws Exception */ public void createClassFromTag( final String className, final Object packge, final Object project, String insideTagBody, final Map<String, Object> contextMap, final Map<String, Object> placeHolders, final ICompilationUnit compUnit, final String typeToCreate, final String spacesBeforeCursor, boolean overrideMethods, final boolean exist, final boolean overWrite) throws JavaModelException, Exception { final VersionControlPreferences versionControlPreferences = VersionControlPreferences.getInstance(); if (typeToCreate.equals(ACTION_ENTITY.Innerclass.getValue())) { compUnit.becomeWorkingCopy(null); final File newFileObj = new File(compUnit.getResource().getLocationURI().toString()); /*final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance(); checkinCache.getFilesToCheckIn().add(new FastCodeFileForCheckin(INITIATED, newFileObj.getAbsolutePath()));*/ try { // addOrUpdateFileStatusInCache(newFileObj); final IType innerClassType = SourceUtil.createInnerClass(insideTagBody, compUnit); /*final boolean prjShared = !isEmpty(compUnit.getResource().getProject().getPersistentProperties()); final boolean prjConfigured = !isEmpty(isPrjConfigured(compUnit.getResource().getProject().getName()));*/ if ((Boolean) placeHolders.get(AUTO_CHECKIN)) { if (proceedWithAutoCheckin(newFileObj, compUnit.getResource().getProject())) { final IFile file = (IFile) innerClassType.getResource(); // .getLocationURI()); List<FastCodeEntityHolder> chngsForType = ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)) .get(file); if (chngsForType == null) { chngsForType = new ArrayList<FastCodeEntityHolder>(); final List<Object> innerClassList = new ArrayList<Object>(); innerClassList.add(new FastCodeType(innerClassType)); chngsForType.add(new FastCodeEntityHolder(PLACEHOLDER_INNERCLASSES, innerClassList)); } else { boolean isNew = true; Object fastCodeFieldList = null; for (final FastCodeEntityHolder fcEntityHolder : chngsForType) { if (fcEntityHolder.getEntityName().equals(PLACEHOLDER_INNERCLASSES)) { fastCodeFieldList = fcEntityHolder.getFastCodeEntity(); isNew = false; break; } } if (isNew) { fastCodeFieldList = new ArrayList<Object>(); ((List<Object>) fastCodeFieldList).add(innerClassType); chngsForType.add( new FastCodeEntityHolder(PLACEHOLDER_INNERCLASSES, fastCodeFieldList)); } else { ((List<Object>) fastCodeFieldList).add(innerClassType); } /*Object innerClassList = chngsForType.get("innerClasses"); if (innerClassList == null) { innerClassList = new ArrayList<Object>(); } ((List<Object>) innerClassList).add(new FastCodeType(innerClassType)); chngsForType.put("innerClasses", innerClassList);*/ } ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)) .put(file, chngsForType); } } } catch (final FastCodeRepositoryException ex) { ex.printStackTrace(); } compUnit.commitWorkingCopy(false, null); compUnit.discardWorkingCopy(); return; } final IJavaProject prj = project instanceof String ? getJavaProject((String) project) : (IJavaProject) project; /*IJavaProject prj = getJavaProject(project);// getJavaProject(attributes.get(PLACEHOLDER_PROJECT)); if (prj == null) { prj = getJavaProject(placeHolders.get(PLACEHOLDER_PROJECT) instanceof FastCodeProject ? ((FastCodeProject) placeHolders .get(PLACEHOLDER_PROJECT)).getName() : (String) placeHolders.get(PLACEHOLDER_PROJECT)); } if (prj == null) { prj = this.javaProject = this.javaProject == null ? getWorkingJavaProjectFromUser() : this.javaProject;//did for j2ee base }*/ if (prj == null) { throw new Exception("Can not continue without java project."); } final String srcPath = typeToCreate.equals(ACTION_ENTITY.Test.getValue()) ? getDefaultPathFromProject(prj, typeToCreate, EMPTY_STR) : getDefaultPathFromProject(prj, "source", EMPTY_STR); IPackageFragment pkgFrgmt = null; final TemplateTagsProcessor templateTagsProcessor = new TemplateTagsProcessor(); if (packge instanceof String && !isEmpty((String) packge) || packge instanceof IPackageFragment) { pkgFrgmt = packge instanceof String ? templateTagsProcessor.getPackageFragment( prj, srcPath, (String) packge, typeToCreate.equals(ACTION_ENTITY.Test.getValue()) ? typeToCreate : "source") : (IPackageFragment) packge; } if (pkgFrgmt == null) { /*final boolean prjShared = !isEmpty(prj.getProject().getPersistentProperties()); final boolean prjConfigured = !isEmpty(isPrjConfigured(prj.getProject().getName()));*/ File file = null; if ((Boolean) placeHolders.get(AUTO_CHECKIN)) { if (proceedWithAutoCheckin(file, prj.getProject())) { final String prjURI = prj.getResource().getLocationURI().toString(); final String path = prjURI.substring(prjURI.indexOf(COLON) + 1); final String newPackURL = path + srcPath + FILE_SEPARATOR + ((String) packge).replace(DOT, FILE_SEPARATOR); file = new File(newPackURL); // final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance(); addOrUpdateFileStatusInCache(file); // checkinCache.getFilesToCheckIn().add(new FastCodeFileForCheckin(INITIATED, // file.getAbsolutePath())); } } pkgFrgmt = templateTagsProcessor.createPackage( prj, (String) packge, typeToCreate, contextMap); // createPackage(prj, // attributes.get(PLACEHOLDER_PACKAGE)); if ((Boolean) placeHolders.get(AUTO_CHECKIN)) { if (proceedWithAutoCheckin(null, prj.getProject())) { final IFile ifile = getIFileFromFile(file); List<FastCodeEntityHolder> chngsForType = ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)).get(ifile); if (chngsForType == null) { chngsForType = new ArrayList<FastCodeEntityHolder>(); chngsForType.add( new FastCodeEntityHolder(PLACEHOLDER_PACKAGE, new FastCodePackage(pkgFrgmt))); } ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)) .put(ifile, chngsForType); } } } boolean createFileAlone = true; if ((Boolean) placeHolders.get(AUTO_CHECKIN)) { String path; try { final boolean prjShared = !isEmpty(pkgFrgmt.getResource().getProject().getPersistentProperties()); final boolean prjConfigured = !isEmpty(isPrjConfigured(pkgFrgmt.getResource().getProject().getName())); createFileAlone = !(versionControlPreferences.isEnable() && prjShared && prjConfigured); final String prjURI = pkgFrgmt.getResource().getLocationURI().toString(); path = prjURI.substring(prjURI.indexOf(COLON) + 1); final File newFileObj = new File(path + FORWARD_SLASH + className + DOT + JAVA_EXTENSION); if (versionControlPreferences.isEnable() && prjShared && prjConfigured) { final RepositoryService repositoryService = getRepositoryServiceClass(); try { if (repositoryService.isFileInRepository( newFileObj)) { // && !MessageDialog.openQuestion(new Shell(), "File present in // repository", "File already present in repository. Click yes to // overwrite")) { /*MessageDialog.openWarning(new Shell(), "File present in repository", className + " is already present in repository. Please synchronise and try again."); return;*/ createFileAlone = MessageDialog.openQuestion( new Shell(), "File present in repository", "File " + newFileObj.getName() + " already present in repository. Click yes to just create the file, No to return without any action."); if (!createFileAlone) { return; } } } catch (final Throwable th) { th.printStackTrace(); createFileAlone = true; } } final FastCodeCheckinCache checkinCache = FastCodeCheckinCache.getInstance(); checkinCache .getFilesToCheckIn() .add(new FastCodeFileForCheckin(INITIATED, newFileObj.getAbsolutePath())); } catch (final FastCodeRepositoryException ex) { ex.printStackTrace(); } } /*if (parseClassName(insideTagBody) == null) { insideTagBody = MODIFIER_PUBLIC + SPACE + typeToCreate + SPACE + className + SPACE + LEFT_CURL + NEWLINE + insideTagBody + NEWLINE + RIGHT_CURL; }*/ final Object codeFormatter = createCodeFormatter(prj.getProject()); if (!isEmpty(insideTagBody)) { insideTagBody = formatCode(insideTagBody.trim(), codeFormatter); } ICompilationUnit compilationUnit = null; if (exist) { if (overWrite) { final IType type = prj.findType(pkgFrgmt.getElementName() + DOT + className.trim()); if (type.getCompilationUnit().hasUnsavedChanges()) { type.getCompilationUnit().save(new NullProgressMonitor(), true); } // type.getCompilationUnit().delete(true, new NullProgressMonitor()); insideTagBody = buildClass(insideTagBody, pkgFrgmt, prj, className); // type.getCompilationUnit().getBuffer().setContents(insideTagBody); final ReplaceEdit replaceEdit = new ReplaceEdit(0, type.getCompilationUnit().getSource().length(), insideTagBody); type.getCompilationUnit().applyTextEdit(replaceEdit, new NullProgressMonitor()); compilationUnit = type.getCompilationUnit(); compilationUnit.becomeWorkingCopy(null); compilationUnit.commitWorkingCopy(false, null); compilationUnit.discardWorkingCopy(); // refreshProject(prj.getElementName()); } else { return; } } else { compilationUnit = SourceUtil.createClass(insideTagBody, pkgFrgmt, prj, className); } if (compilationUnit == null) { return; } if (!typeToCreate.equals(ACTION_ENTITY.Interface.getValue())) { if (compilationUnit.findPrimaryType().getSuperclassName() != null) { final IType superClassType = prj.findType( getFQNameFromFieldTypeName( compilationUnit.findPrimaryType().getSuperclassName(), compilationUnit)); if (superClassType != null && superClassType.exists()) { if (Flags.isAbstract( superClassType .getFlags()) /*Modifier.isAbstract(Class.forName(superClassType.getFullyQualifiedName()).getModifiers())*/) { overrideMethods = true; } } } if (overrideMethods) { final String superInterfaces[] = compilationUnit.findPrimaryType().getSuperInterfaceNames(); if (superInterfaces != null) { for (final String superInertafce : superInterfaces) { final IType superIntType = prj.findType(getFQNameFromFieldTypeName(superInertafce, compilationUnit)); final FastCodeContext fastCodeContext = new FastCodeContext(superIntType); final CreateSimilarDescriptorClass createSimilarDescriptorClass = new CreateSimilarDescriptorClass.Builder().withClassType(CLASS_TYPE.CLASS).build(); implementInterfaceMethods( superIntType, fastCodeContext, compilationUnit.findPrimaryType(), null, createSimilarDescriptorClass); final IType[] superInterfaceType = getSuperInterfacesType(superIntType); if (superInterfaceType != null) { for (final IType type : superInterfaceType) { if (type == null || !type.exists()) { continue; } final FastCodeContext context = new FastCodeContext(type); implementInterfaceMethods( type, context, compilationUnit.findPrimaryType(), null, createSimilarDescriptorClass); } } } } overrideBaseClassMethods(compilationUnit); } } /* * final IType newType = compilationUnit.findPrimaryType(); String * superClassName = newType.getSuperclassName(); if * (!isEmpty(superClassName)) { final IType superClassType = * prj.findType(getFQNameFromFieldTypeName(newType.getSuperclassName(), * newType.getCompilationUnit())); final FastCodeContext fastCodeContext * = new FastCodeContext(superClassType); final * CreateSimilarDescriptorClass createSimilarDescriptorClass = new * CreateSimilarDescriptorClass.Builder().withClassType( * CLASS_TYPE.CLASS).build(); for (final IMethod method : * superClassType.getMethods()) { if (method.isConstructor()) { * overrideConstructor(method, newType); final MethodBuilder * methodBuilder = new SimilarMethodBuilder(fastCodeContext); * methodBuilder.buildMethod(method, newType, null, * createSimilarDescriptorClass); } } } */ contextMap.put( "Class_" + compilationUnit.getElementName(), new FastCodeObject(compilationUnit, ACTION_ENTITY.Class.getValue())); if (!createFileAlone) { final IFile fileObj = (IFile) compilationUnit.findPrimaryType().getResource(); // .getLocationURI()); List<FastCodeEntityHolder> chngsForType = ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)).get(fileObj); if (chngsForType == null) { chngsForType = new ArrayList<FastCodeEntityHolder>(); chngsForType.add( new FastCodeEntityHolder( PLACEHOLDER_CLASS, new FastCodeType(compilationUnit.findPrimaryType()))); } ((Map<Object, List<FastCodeEntityHolder>>) contextMap.get(FC_OBJ_CREATED)) .put(fileObj, chngsForType); } /*final Map<String, Object> listofChange = ((Map<Object, Map<String, Object>>) contextMap.get("changes_for_File")).get(file); if (chngsForType == null) { chngsForType = new HashMap<String, Object>(); chngsForType.put("class", CREATE_CLASS); //fastCodeCache.getCommentKey().get(fastCodeCache.getCommentKey().indexOf("create.class.field")) } ((Map<Object, Map<String, Object>>) contextMap.get("changes_for_File")).put(file, listofChange);*/ }
/** * Determines whether the given member is a valid android.view.View to be added to the list of * custom views or third party views. It checks that the view is public and not abstract for * example. */ private static boolean isValidView(IType type, boolean layoutsOnly) throws JavaModelException { // Skip anonymous classes if (type.isAnonymous()) { return false; } int flags = type.getFlags(); if (Flags.isAbstract(flags) || !Flags.isPublic(flags)) { return false; } // TODO: if (layoutsOnly) perhaps try to filter out AdapterViews and other ViewGroups // not willing to accept children via XML // See if the class has one of the acceptable constructors // needed for XML instantiation: // View(Context context) // View(Context context, AttributeSet attrs) // View(Context context, AttributeSet attrs, int defStyle) // We don't simply do three direct checks via type.getMethod() because the types // are not resolved, so we don't know for each parameter if we will get the // fully qualified or the unqualified class names. // Instead, iterate over the methods and look for a match. String typeName = type.getElementName(); for (IMethod method : type.getMethods()) { // Only care about constructors if (!method.getElementName().equals(typeName)) { continue; } String[] parameterTypes = method.getParameterTypes(); if (parameterTypes == null || parameterTypes.length < 1 || parameterTypes.length > 3) { continue; } String first = parameterTypes[0]; // Look for the parameter type signatures -- produced by // JDT's Signature.createTypeSignature("Context", false /*isResolved*/);. // This is not a typo; they were copy/pasted from the actual parameter names // observed in the debugger examining these data structures. if (first.equals("QContext;") // $NON-NLS-1$ || first.equals("Qandroid.content.Context;")) { // $NON-NLS-1$ if (parameterTypes.length == 1) { return true; } String second = parameterTypes[1]; if (second.equals("QAttributeSet;") // $NON-NLS-1$ || second.equals("Qandroid.util.AttributeSet;")) { // $NON-NLS-1$ if (parameterTypes.length == 2) { return true; } String third = parameterTypes[2]; if (third.equals("I")) { // $NON-NLS-1$ if (parameterTypes.length == 3) { return true; } } } } } return false; }
private boolean isCacheableRHS(IType type) throws JavaModelException { return !type.isInterface() && !Flags.isAbstract(type.getFlags()); }
private boolean isCacheableLHS(IType type, String qualifiedName) throws JavaModelException { return !Flags.isFinal(type.getFlags()) && !UNCACHEABLE.contains(qualifiedName); }