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);
}
